':
+ depth = 0
+ for piece in pieces[:-1]:
+ if piece.startswith(''):
+ depth += 1
+ else:
+ pieces = pieces[1:-1]
+
+ # Ensure each piece is a str for Python 3
+ for (i, v) in enumerate(pieces):
+ if not isinstance(v, basestring):
+ pieces[i] = v.decode('utf-8')
+
+ output = ''.join(pieces)
+ if stripWhitespace:
+ output = output.strip()
+ if not expectingText: return output
+
+ # decode base64 content
+ if base64 and self.contentparams.get('base64', 0):
+ try:
+ output = _base64decode(output)
+ except binascii.Error:
+ pass
+ except binascii.Incomplete:
+ pass
+ except TypeError:
+ # In Python 3, base64 takes and outputs bytes, not str
+ # This may not be the most correct way to accomplish this
+ output = _base64decode(output.encode('utf-8')).decode('utf-8')
+
+ # resolve relative URIs
+ if (element in self.can_be_relative_uri) and output:
+ output = self.resolveURI(output)
+
+ # decode entities within embedded markup
+ if not self.contentparams.get('base64', 0):
+ output = self.decodeEntities(element, output)
+
+ if self.lookslikehtml(output):
+ self.contentparams['type']='text/html'
+
+ # remove temporary cruft from contentparams
+ try:
+ del self.contentparams['mode']
+ except KeyError:
+ pass
+ try:
+ del self.contentparams['base64']
+ except KeyError:
+ pass
+
+ is_htmlish = self.mapContentType(self.contentparams.get('type', 'text/html')) in self.html_types
+ # resolve relative URIs within embedded markup
+ if is_htmlish and RESOLVE_RELATIVE_URIS:
+ if element in self.can_contain_relative_uris:
+ output = _resolveRelativeURIs(output, self.baseuri, self.encoding, self.contentparams.get('type', 'text/html'))
+
+ # parse microformats
+ # (must do this before sanitizing because some microformats
+ # rely on elements that we sanitize)
+ if is_htmlish and element in ['content', 'description', 'summary']:
+ mfresults = _parseMicroformats(output, self.baseuri, self.encoding)
+ if mfresults:
+ for tag in mfresults.get('tags', []):
+ self._addTag(tag['term'], tag['scheme'], tag['label'])
+ for enclosure in mfresults.get('enclosures', []):
+ self._start_enclosure(enclosure)
+ for xfn in mfresults.get('xfn', []):
+ self._addXFN(xfn['relationships'], xfn['href'], xfn['name'])
+ vcard = mfresults.get('vcard')
+ if vcard:
+ self._getContext()['vcard'] = vcard
+
+ # sanitize embedded markup
+ if is_htmlish and SANITIZE_HTML:
+ if element in self.can_contain_dangerous_markup:
+ output = _sanitizeHTML(output, self.encoding, self.contentparams.get('type', 'text/html'))
+
+ if self.encoding and type(output) != type(u''):
+ try:
+ output = unicode(output, self.encoding)
+ except:
+ pass
+
+ # address common error where people take data that is already
+ # utf-8, presume that it is iso-8859-1, and re-encode it.
+ if self.encoding in ('utf-8', 'utf-8_INVALID_PYTHON_3') and type(output) == type(u''):
+ try:
+ output = unicode(output.encode('iso-8859-1'), 'utf-8')
+ except:
+ pass
+
+ # map win-1252 extensions to the proper code points
+ if type(output) == type(u''):
+ output = u''.join([c in _cp1252.keys() and _cp1252[c] or c for c in output])
+
+ # categories/tags/keywords/whatever are handled in _end_category
+ if element == 'category':
+ return output
+
+ if element == 'title' and self.hasTitle:
+ return output
+
+ # store output in appropriate place(s)
+ if self.inentry and not self.insource:
+ if element == 'content':
+ self.entries[-1].setdefault(element, [])
+ contentparams = copy.deepcopy(self.contentparams)
+ contentparams['value'] = output
+ self.entries[-1][element].append(contentparams)
+ elif element == 'link':
+ if not self.inimage:
+ # query variables in urls in link elements are improperly
+ # converted from `?a=1&b=2` to `?a=1&b;=2` as if they're
+ # unhandled character references. fix this special case.
+ output = re.sub("&([A-Za-z0-9_]+);", "&\g<1>", output)
+ self.entries[-1][element] = output
+ if output:
+ self.entries[-1]['links'][-1]['href'] = output
+ else:
+ if element == 'description':
+ element = 'summary'
+ self.entries[-1][element] = output
+ if self.incontent:
+ contentparams = copy.deepcopy(self.contentparams)
+ contentparams['value'] = output
+ self.entries[-1][element + '_detail'] = contentparams
+ elif (self.infeed or self.insource):# and (not self.intextinput) and (not self.inimage):
+ context = self._getContext()
+ if element == 'description':
+ element = 'subtitle'
+ context[element] = output
+ if element == 'link':
+ # fix query variables; see above for the explanation
+ output = re.sub("&([A-Za-z0-9_]+);", "&\g<1>", output)
+ context[element] = output
+ context['links'][-1]['href'] = output
+ elif self.incontent:
+ contentparams = copy.deepcopy(self.contentparams)
+ contentparams['value'] = output
+ context[element + '_detail'] = contentparams
+ return output
+
+ def pushContent(self, tag, attrsD, defaultContentType, expectingText):
+ self.incontent += 1
+ if self.lang: self.lang=self.lang.replace('_','-')
+ self.contentparams = FeedParserDict({
+ 'type': self.mapContentType(attrsD.get('type', defaultContentType)),
+ 'language': self.lang,
+ 'base': self.baseuri})
+ self.contentparams['base64'] = self._isBase64(attrsD, self.contentparams)
+ self.push(tag, expectingText)
+
+ def popContent(self, tag):
+ value = self.pop(tag)
+ self.incontent -= 1
+ self.contentparams.clear()
+ return value
+
+ # a number of elements in a number of RSS variants are nominally plain
+ # text, but this is routinely ignored. This is an attempt to detect
+ # the most common cases. As false positives often result in silent
+ # data loss, this function errs on the conservative side.
+ def lookslikehtml(self, s):
+ if self.version.startswith('atom'): return
+ if self.contentparams.get('type','text/html') != 'text/plain': return
+
+ # must have a close tag or a entity reference to qualify
+ if not (re.search(r'',s) or re.search("&#?\w+;",s)): return
+
+ # all tags must be in a restricted subset of valid HTML tags
+ if filter(lambda t: t.lower() not in _HTMLSanitizer.acceptable_elements,
+ re.findall(r' -1:
+ prefix = name[:colonpos]
+ suffix = name[colonpos+1:]
+ prefix = self.namespacemap.get(prefix, prefix)
+ name = prefix + ':' + suffix
+ return name
+
+ def _getAttribute(self, attrsD, name):
+ return attrsD.get(self._mapToStandardPrefix(name))
+
+ def _isBase64(self, attrsD, contentparams):
+ if attrsD.get('mode', '') == 'base64':
+ return 1
+ if self.contentparams['type'].startswith('text/'):
+ return 0
+ if self.contentparams['type'].endswith('+xml'):
+ return 0
+ if self.contentparams['type'].endswith('/xml'):
+ return 0
+ return 1
+
+ def _itsAnHrefDamnIt(self, attrsD):
+ href = attrsD.get('url', attrsD.get('uri', attrsD.get('href', None)))
+ if href:
+ try:
+ del attrsD['url']
+ except KeyError:
+ pass
+ try:
+ del attrsD['uri']
+ except KeyError:
+ pass
+ attrsD['href'] = href
+ return attrsD
+
+ def _save(self, key, value, overwrite=False):
+ context = self._getContext()
+ if overwrite:
+ context[key] = value
+ else:
+ context.setdefault(key, value)
+
+ def _start_rss(self, attrsD):
+ versionmap = {'0.91': 'rss091u',
+ '0.92': 'rss092',
+ '0.93': 'rss093',
+ '0.94': 'rss094'}
+ #If we're here then this is an RSS feed.
+ #If we don't have a version or have a version that starts with something
+ #other than RSS then there's been a mistake. Correct it.
+ if not self.version or not self.version.startswith('rss'):
+ attr_version = attrsD.get('version', '')
+ version = versionmap.get(attr_version)
+ if version:
+ self.version = version
+ elif attr_version.startswith('2.'):
+ self.version = 'rss20'
+ else:
+ self.version = 'rss'
+
+ def _start_dlhottitles(self, attrsD):
+ self.version = 'hotrss'
+
+ def _start_channel(self, attrsD):
+ self.infeed = 1
+ self._cdf_common(attrsD)
+ _start_feedinfo = _start_channel
+
+ def _cdf_common(self, attrsD):
+ if attrsD.has_key('lastmod'):
+ self._start_modified({})
+ self.elementstack[-1][-1] = attrsD['lastmod']
+ self._end_modified()
+ if attrsD.has_key('href'):
+ self._start_link({})
+ self.elementstack[-1][-1] = attrsD['href']
+ self._end_link()
+
+ def _start_feed(self, attrsD):
+ self.infeed = 1
+ versionmap = {'0.1': 'atom01',
+ '0.2': 'atom02',
+ '0.3': 'atom03'}
+ if not self.version:
+ attr_version = attrsD.get('version')
+ version = versionmap.get(attr_version)
+ if version:
+ self.version = version
+ else:
+ self.version = 'atom'
+
+ def _end_channel(self):
+ self.infeed = 0
+ _end_feed = _end_channel
+
+ def _start_image(self, attrsD):
+ context = self._getContext()
+ if not self.inentry:
+ context.setdefault('image', FeedParserDict())
+ self.inimage = 1
+ self.hasTitle = 0
+ self.push('image', 0)
+
+ def _end_image(self):
+ self.pop('image')
+ self.inimage = 0
+
+ def _start_textinput(self, attrsD):
+ context = self._getContext()
+ context.setdefault('textinput', FeedParserDict())
+ self.intextinput = 1
+ self.hasTitle = 0
+ self.push('textinput', 0)
+ _start_textInput = _start_textinput
+
+ def _end_textinput(self):
+ self.pop('textinput')
+ self.intextinput = 0
+ _end_textInput = _end_textinput
+
+ def _start_author(self, attrsD):
+ self.inauthor = 1
+ self.push('author', 1)
+ # Append a new FeedParserDict when expecting an author
+ context = self._getContext()
+ context.setdefault('authors', [])
+ context['authors'].append(FeedParserDict())
+ _start_managingeditor = _start_author
+ _start_dc_author = _start_author
+ _start_dc_creator = _start_author
+ _start_itunes_author = _start_author
+
+ def _end_author(self):
+ self.pop('author')
+ self.inauthor = 0
+ self._sync_author_detail()
+ _end_managingeditor = _end_author
+ _end_dc_author = _end_author
+ _end_dc_creator = _end_author
+ _end_itunes_author = _end_author
+
+ def _start_itunes_owner(self, attrsD):
+ self.inpublisher = 1
+ self.push('publisher', 0)
+
+ def _end_itunes_owner(self):
+ self.pop('publisher')
+ self.inpublisher = 0
+ self._sync_author_detail('publisher')
+
+ def _start_contributor(self, attrsD):
+ self.incontributor = 1
+ context = self._getContext()
+ context.setdefault('contributors', [])
+ context['contributors'].append(FeedParserDict())
+ self.push('contributor', 0)
+
+ def _end_contributor(self):
+ self.pop('contributor')
+ self.incontributor = 0
+
+ def _start_dc_contributor(self, attrsD):
+ self.incontributor = 1
+ context = self._getContext()
+ context.setdefault('contributors', [])
+ context['contributors'].append(FeedParserDict())
+ self.push('name', 0)
+
+ def _end_dc_contributor(self):
+ self._end_name()
+ self.incontributor = 0
+
+ def _start_name(self, attrsD):
+ self.push('name', 0)
+ _start_itunes_name = _start_name
+
+ def _end_name(self):
+ value = self.pop('name')
+ if self.inpublisher:
+ self._save_author('name', value, 'publisher')
+ elif self.inauthor:
+ self._save_author('name', value)
+ elif self.incontributor:
+ self._save_contributor('name', value)
+ elif self.intextinput:
+ context = self._getContext()
+ context['name'] = value
+ _end_itunes_name = _end_name
+
+ def _start_width(self, attrsD):
+ self.push('width', 0)
+
+ def _end_width(self):
+ value = self.pop('width')
+ try:
+ value = int(value)
+ except:
+ value = 0
+ if self.inimage:
+ context = self._getContext()
+ context['width'] = value
+
+ def _start_height(self, attrsD):
+ self.push('height', 0)
+
+ def _end_height(self):
+ value = self.pop('height')
+ try:
+ value = int(value)
+ except:
+ value = 0
+ if self.inimage:
+ context = self._getContext()
+ context['height'] = value
+
+ def _start_url(self, attrsD):
+ self.push('href', 1)
+ _start_homepage = _start_url
+ _start_uri = _start_url
+
+ def _end_url(self):
+ value = self.pop('href')
+ if self.inauthor:
+ self._save_author('href', value)
+ elif self.incontributor:
+ self._save_contributor('href', value)
+ _end_homepage = _end_url
+ _end_uri = _end_url
+
+ def _start_email(self, attrsD):
+ self.push('email', 0)
+ _start_itunes_email = _start_email
+
+ def _end_email(self):
+ value = self.pop('email')
+ if self.inpublisher:
+ self._save_author('email', value, 'publisher')
+ elif self.inauthor:
+ self._save_author('email', value)
+ elif self.incontributor:
+ self._save_contributor('email', value)
+ _end_itunes_email = _end_email
+
+ def _getContext(self):
+ if self.insource:
+ context = self.sourcedata
+ elif self.inimage and self.feeddata.has_key('image'):
+ context = self.feeddata['image']
+ elif self.intextinput:
+ context = self.feeddata['textinput']
+ elif self.inentry:
+ context = self.entries[-1]
+ else:
+ context = self.feeddata
+ return context
+
+ def _save_author(self, key, value, prefix='author'):
+ context = self._getContext()
+ context.setdefault(prefix + '_detail', FeedParserDict())
+ context[prefix + '_detail'][key] = value
+ self._sync_author_detail()
+ context.setdefault('authors', [FeedParserDict()])
+ context['authors'][-1][key] = value
+
+ def _save_contributor(self, key, value):
+ context = self._getContext()
+ context.setdefault('contributors', [FeedParserDict()])
+ context['contributors'][-1][key] = value
+
+ def _sync_author_detail(self, key='author'):
+ context = self._getContext()
+ detail = context.get('%s_detail' % key)
+ if detail:
+ name = detail.get('name')
+ email = detail.get('email')
+ if name and email:
+ context[key] = '%s (%s)' % (name, email)
+ elif name:
+ context[key] = name
+ elif email:
+ context[key] = email
+ else:
+ author, email = context.get(key), None
+ if not author: return
+ emailmatch = re.search(r'''(([a-zA-Z0-9\_\-\.\+]+)@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.)|(([a-zA-Z0-9\-]+\.)+))([a-zA-Z]{2,4}|[0-9]{1,3})(\]?))(\?subject=\S+)?''', author)
+ if emailmatch:
+ email = emailmatch.group(0)
+ # probably a better way to do the following, but it passes all the tests
+ author = author.replace(email, '')
+ author = author.replace('()', '')
+ author = author.replace('<>', '')
+ author = author.replace('<>', '')
+ author = author.strip()
+ if author and (author[0] == '('):
+ author = author[1:]
+ if author and (author[-1] == ')'):
+ author = author[:-1]
+ author = author.strip()
+ if author or email:
+ context.setdefault('%s_detail' % key, FeedParserDict())
+ if author:
+ context['%s_detail' % key]['name'] = author
+ if email:
+ context['%s_detail' % key]['email'] = email
+
+ def _start_subtitle(self, attrsD):
+ self.pushContent('subtitle', attrsD, 'text/plain', 1)
+ _start_tagline = _start_subtitle
+ _start_itunes_subtitle = _start_subtitle
+
+ def _end_subtitle(self):
+ self.popContent('subtitle')
+ _end_tagline = _end_subtitle
+ _end_itunes_subtitle = _end_subtitle
+
+ def _start_rights(self, attrsD):
+ self.pushContent('rights', attrsD, 'text/plain', 1)
+ _start_dc_rights = _start_rights
+ _start_copyright = _start_rights
+
+ def _end_rights(self):
+ self.popContent('rights')
+ _end_dc_rights = _end_rights
+ _end_copyright = _end_rights
+
+ def _start_item(self, attrsD):
+ self.entries.append(FeedParserDict())
+ self.push('item', 0)
+ self.inentry = 1
+ self.guidislink = 0
+ self.hasTitle = 0
+ id = self._getAttribute(attrsD, 'rdf:about')
+ if id:
+ context = self._getContext()
+ context['id'] = id
+ self._cdf_common(attrsD)
+ _start_entry = _start_item
+ _start_product = _start_item
+
+ def _end_item(self):
+ self.pop('item')
+ self.inentry = 0
+ _end_entry = _end_item
+
+ def _start_dc_language(self, attrsD):
+ self.push('language', 1)
+ _start_language = _start_dc_language
+
+ def _end_dc_language(self):
+ self.lang = self.pop('language')
+ _end_language = _end_dc_language
+
+ def _start_dc_publisher(self, attrsD):
+ self.push('publisher', 1)
+ _start_webmaster = _start_dc_publisher
+
+ def _end_dc_publisher(self):
+ self.pop('publisher')
+ self._sync_author_detail('publisher')
+ _end_webmaster = _end_dc_publisher
+
+ def _start_published(self, attrsD):
+ self.push('published', 1)
+ _start_dcterms_issued = _start_published
+ _start_issued = _start_published
+
+ def _end_published(self):
+ value = self.pop('published')
+ self._save('published_parsed', _parse_date(value), overwrite=True)
+ _end_dcterms_issued = _end_published
+ _end_issued = _end_published
+
+ def _start_updated(self, attrsD):
+ self.push('updated', 1)
+ _start_modified = _start_updated
+ _start_dcterms_modified = _start_updated
+ _start_pubdate = _start_updated
+ _start_dc_date = _start_updated
+ _start_lastbuilddate = _start_updated
+
+ def _end_updated(self):
+ value = self.pop('updated')
+ parsed_value = _parse_date(value)
+ self._save('updated_parsed', parsed_value, overwrite=True)
+ _end_modified = _end_updated
+ _end_dcterms_modified = _end_updated
+ _end_pubdate = _end_updated
+ _end_dc_date = _end_updated
+ _end_lastbuilddate = _end_updated
+
+ def _start_created(self, attrsD):
+ self.push('created', 1)
+ _start_dcterms_created = _start_created
+
+ def _end_created(self):
+ value = self.pop('created')
+ self._save('created_parsed', _parse_date(value), overwrite=True)
+ _end_dcterms_created = _end_created
+
+ def _start_expirationdate(self, attrsD):
+ self.push('expired', 1)
+
+ def _end_expirationdate(self):
+ self._save('expired_parsed', _parse_date(self.pop('expired')), overwrite=True)
+
+ def _start_cc_license(self, attrsD):
+ context = self._getContext()
+ value = self._getAttribute(attrsD, 'rdf:resource')
+ attrsD = FeedParserDict()
+ attrsD['rel']='license'
+ if value: attrsD['href']=value
+ context.setdefault('links', []).append(attrsD)
+
+ def _start_creativecommons_license(self, attrsD):
+ self.push('license', 1)
+ _start_creativeCommons_license = _start_creativecommons_license
+
+ def _end_creativecommons_license(self):
+ value = self.pop('license')
+ context = self._getContext()
+ attrsD = FeedParserDict()
+ attrsD['rel']='license'
+ if value: attrsD['href']=value
+ context.setdefault('links', []).append(attrsD)
+ del context['license']
+ _end_creativeCommons_license = _end_creativecommons_license
+
+ def _addXFN(self, relationships, href, name):
+ context = self._getContext()
+ xfn = context.setdefault('xfn', [])
+ value = FeedParserDict({'relationships': relationships, 'href': href, 'name': name})
+ if value not in xfn:
+ xfn.append(value)
+
+ def _addTag(self, term, scheme, label):
+ context = self._getContext()
+ tags = context.setdefault('tags', [])
+ if (not term) and (not scheme) and (not label): return
+ value = FeedParserDict({'term': term, 'scheme': scheme, 'label': label})
+ if value not in tags:
+ tags.append(value)
+
+ def _start_category(self, attrsD):
+ if _debug: sys.stderr.write('entering _start_category with %s\n' % repr(attrsD))
+ term = attrsD.get('term')
+ scheme = attrsD.get('scheme', attrsD.get('domain'))
+ label = attrsD.get('label')
+ self._addTag(term, scheme, label)
+ self.push('category', 1)
+ _start_dc_subject = _start_category
+ _start_keywords = _start_category
+
+ def _start_media_category(self, attrsD):
+ attrsD.setdefault('scheme', 'http://search.yahoo.com/mrss/category_schema')
+ self._start_category(attrsD)
+
+ def _end_itunes_keywords(self):
+ for term in self.pop('itunes_keywords').split():
+ self._addTag(term, 'http://www.itunes.com/', None)
+
+ def _start_itunes_category(self, attrsD):
+ self._addTag(attrsD.get('text'), 'http://www.itunes.com/', None)
+ self.push('category', 1)
+
+ def _end_category(self):
+ value = self.pop('category')
+ if not value: return
+ context = self._getContext()
+ tags = context['tags']
+ if value and len(tags) and not tags[-1]['term']:
+ tags[-1]['term'] = value
+ else:
+ self._addTag(value, None, None)
+ _end_dc_subject = _end_category
+ _end_keywords = _end_category
+ _end_itunes_category = _end_category
+ _end_media_category = _end_category
+
+ def _start_cloud(self, attrsD):
+ self._getContext()['cloud'] = FeedParserDict(attrsD)
+
+ def _start_link(self, attrsD):
+ attrsD.setdefault('rel', 'alternate')
+ if attrsD['rel'] == 'self':
+ attrsD.setdefault('type', 'application/atom+xml')
+ else:
+ attrsD.setdefault('type', 'text/html')
+ context = self._getContext()
+ attrsD = self._itsAnHrefDamnIt(attrsD)
+ if attrsD.has_key('href'):
+ attrsD['href'] = self.resolveURI(attrsD['href'])
+ expectingText = self.infeed or self.inentry or self.insource
+ context.setdefault('links', [])
+ if not (self.inentry and self.inimage):
+ context['links'].append(FeedParserDict(attrsD))
+ if attrsD.has_key('href'):
+ expectingText = 0
+ if (attrsD.get('rel') == 'alternate') and (self.mapContentType(attrsD.get('type')) in self.html_types):
+ context['link'] = attrsD['href']
+ else:
+ self.push('link', expectingText)
+ _start_producturl = _start_link
+
+ def _end_link(self):
+ value = self.pop('link')
+ context = self._getContext()
+ _end_producturl = _end_link
+
+ def _start_guid(self, attrsD):
+ self.guidislink = (attrsD.get('ispermalink', 'true') == 'true')
+ self.push('id', 1)
+
+ def _end_guid(self):
+ value = self.pop('id')
+ self._save('guidislink', self.guidislink and not self._getContext().has_key('link'))
+ if self.guidislink:
+ # guid acts as link, but only if 'ispermalink' is not present or is 'true',
+ # and only if the item doesn't already have a link element
+ self._save('link', value)
+
+ def _start_title(self, attrsD):
+ if self.svgOK: return self.unknown_starttag('title', attrsD.items())
+ self.pushContent('title', attrsD, 'text/plain', self.infeed or self.inentry or self.insource)
+ _start_dc_title = _start_title
+ _start_media_title = _start_title
+
+ def _end_title(self):
+ if self.svgOK: return
+ value = self.popContent('title')
+ if not value: return
+ context = self._getContext()
+ self.hasTitle = 1
+ _end_dc_title = _end_title
+
+ def _end_media_title(self):
+ hasTitle = self.hasTitle
+ self._end_title()
+ self.hasTitle = hasTitle
+
+ def _start_description(self, attrsD):
+ context = self._getContext()
+ if context.has_key('summary'):
+ self._summaryKey = 'content'
+ self._start_content(attrsD)
+ else:
+ self.pushContent('description', attrsD, 'text/html', self.infeed or self.inentry or self.insource)
+ _start_dc_description = _start_description
+
+ def _start_abstract(self, attrsD):
+ self.pushContent('description', attrsD, 'text/plain', self.infeed or self.inentry or self.insource)
+
+ def _end_description(self):
+ if self._summaryKey == 'content':
+ self._end_content()
+ else:
+ value = self.popContent('description')
+ self._summaryKey = None
+ _end_abstract = _end_description
+ _end_dc_description = _end_description
+
+ def _start_info(self, attrsD):
+ self.pushContent('info', attrsD, 'text/plain', 1)
+ _start_feedburner_browserfriendly = _start_info
+
+ def _end_info(self):
+ self.popContent('info')
+ _end_feedburner_browserfriendly = _end_info
+
+ def _start_generator(self, attrsD):
+ if attrsD:
+ attrsD = self._itsAnHrefDamnIt(attrsD)
+ if attrsD.has_key('href'):
+ attrsD['href'] = self.resolveURI(attrsD['href'])
+ self._getContext()['generator_detail'] = FeedParserDict(attrsD)
+ self.push('generator', 1)
+
+ def _end_generator(self):
+ value = self.pop('generator')
+ context = self._getContext()
+ if context.has_key('generator_detail'):
+ context['generator_detail']['name'] = value
+
+ def _start_admin_generatoragent(self, attrsD):
+ self.push('generator', 1)
+ value = self._getAttribute(attrsD, 'rdf:resource')
+ if value:
+ self.elementstack[-1][2].append(value)
+ self.pop('generator')
+ self._getContext()['generator_detail'] = FeedParserDict({'href': value})
+
+ def _start_admin_errorreportsto(self, attrsD):
+ self.push('errorreportsto', 1)
+ value = self._getAttribute(attrsD, 'rdf:resource')
+ if value:
+ self.elementstack[-1][2].append(value)
+ self.pop('errorreportsto')
+
+ def _start_summary(self, attrsD):
+ context = self._getContext()
+ if context.has_key('summary'):
+ self._summaryKey = 'content'
+ self._start_content(attrsD)
+ else:
+ self._summaryKey = 'summary'
+ self.pushContent(self._summaryKey, attrsD, 'text/plain', 1)
+ _start_itunes_summary = _start_summary
+
+ def _end_summary(self):
+ if self._summaryKey == 'content':
+ self._end_content()
+ else:
+ self.popContent(self._summaryKey or 'summary')
+ self._summaryKey = None
+ _end_itunes_summary = _end_summary
+
+ def _start_enclosure(self, attrsD):
+ attrsD = self._itsAnHrefDamnIt(attrsD)
+ context = self._getContext()
+ attrsD['rel']='enclosure'
+ context.setdefault('links', []).append(FeedParserDict(attrsD))
+
+ def _start_source(self, attrsD):
+ if 'url' in attrsD:
+ # This means that we're processing a source element from an RSS 2.0 feed
+ self.sourcedata['href'] = attrsD[u'url']
+ self.push('source', 1)
+ self.insource = 1
+ self.hasTitle = 0
+
+ def _end_source(self):
+ self.insource = 0
+ value = self.pop('source')
+ if value:
+ self.sourcedata['title'] = value
+ self._getContext()['source'] = copy.deepcopy(self.sourcedata)
+ self.sourcedata.clear()
+
+ def _start_content(self, attrsD):
+ self.pushContent('content', attrsD, 'text/plain', 1)
+ src = attrsD.get('src')
+ if src:
+ self.contentparams['src'] = src
+ self.push('content', 1)
+
+ def _start_prodlink(self, attrsD):
+ self.pushContent('content', attrsD, 'text/html', 1)
+
+ def _start_body(self, attrsD):
+ self.pushContent('content', attrsD, 'application/xhtml+xml', 1)
+ _start_xhtml_body = _start_body
+
+ def _start_content_encoded(self, attrsD):
+ self.pushContent('content', attrsD, 'text/html', 1)
+ _start_fullitem = _start_content_encoded
+
+ def _end_content(self):
+ copyToSummary = self.mapContentType(self.contentparams.get('type')) in (['text/plain'] + self.html_types)
+ value = self.popContent('content')
+ if copyToSummary:
+ self._save('summary', value)
+
+ _end_body = _end_content
+ _end_xhtml_body = _end_content
+ _end_content_encoded = _end_content
+ _end_fullitem = _end_content
+ _end_prodlink = _end_content
+
+ def _start_itunes_image(self, attrsD):
+ self.push('itunes_image', 0)
+ if attrsD.get('href'):
+ self._getContext()['image'] = FeedParserDict({'href': attrsD.get('href')})
+ _start_itunes_link = _start_itunes_image
+
+ def _end_itunes_block(self):
+ value = self.pop('itunes_block', 0)
+ self._getContext()['itunes_block'] = (value == 'yes') and 1 or 0
+
+ def _end_itunes_explicit(self):
+ value = self.pop('itunes_explicit', 0)
+ # Convert 'yes' -> True, 'clean' to False, and any other value to None
+ # False and None both evaluate as False, so the difference can be ignored
+ # by applications that only need to know if the content is explicit.
+ self._getContext()['itunes_explicit'] = (None, False, True)[(value == 'yes' and 2) or value == 'clean' or 0]
+
+ def _start_media_content(self, attrsD):
+ context = self._getContext()
+ context.setdefault('media_content', [])
+ context['media_content'].append(attrsD)
+
+ def _start_media_thumbnail(self, attrsD):
+ context = self._getContext()
+ context.setdefault('media_thumbnail', [])
+ self.push('url', 1) # new
+ context['media_thumbnail'].append(attrsD)
+
+ def _end_media_thumbnail(self):
+ url = self.pop('url')
+ context = self._getContext()
+ if url != None and len(url.strip()) != 0:
+ if not context['media_thumbnail'][-1].has_key('url'):
+ context['media_thumbnail'][-1]['url'] = url
+
+ def _start_media_player(self, attrsD):
+ self.push('media_player', 0)
+ self._getContext()['media_player'] = FeedParserDict(attrsD)
+
+ def _end_media_player(self):
+ value = self.pop('media_player')
+ context = self._getContext()
+ context['media_player']['content'] = value
+
+ def _start_newlocation(self, attrsD):
+ self.push('newlocation', 1)
+
+ def _end_newlocation(self):
+ url = self.pop('newlocation')
+ context = self._getContext()
+ # don't set newlocation if the context isn't right
+ if context is not self.feeddata:
+ return
+ context['newlocation'] = _makeSafeAbsoluteURI(self.baseuri, url.strip())
+
+if _XML_AVAILABLE:
+ class _StrictFeedParser(_FeedParserMixin, xml.sax.handler.ContentHandler):
+ def __init__(self, baseuri, baselang, encoding):
+ if _debug: sys.stderr.write('trying StrictFeedParser\n')
+ xml.sax.handler.ContentHandler.__init__(self)
+ _FeedParserMixin.__init__(self, baseuri, baselang, encoding)
+ self.bozo = 0
+ self.exc = None
+ self.decls = {}
+
+ def startPrefixMapping(self, prefix, uri):
+ self.trackNamespace(prefix, uri)
+ if uri == 'http://www.w3.org/1999/xlink':
+ self.decls['xmlns:'+prefix] = uri
+
+ def startElementNS(self, name, qname, attrs):
+ namespace, localname = name
+ lowernamespace = str(namespace or '').lower()
+ if lowernamespace.find('backend.userland.com/rss') <> -1:
+ # match any backend.userland.com namespace
+ namespace = 'http://backend.userland.com/rss'
+ lowernamespace = namespace
+ if qname and qname.find(':') > 0:
+ givenprefix = qname.split(':')[0]
+ else:
+ givenprefix = None
+ prefix = self._matchnamespaces.get(lowernamespace, givenprefix)
+ if givenprefix and (prefix == None or (prefix == '' and lowernamespace == '')) and not self.namespacesInUse.has_key(givenprefix):
+ raise UndeclaredNamespace, "'%s' is not associated with a namespace" % givenprefix
+ localname = str(localname).lower()
+
+ # qname implementation is horribly broken in Python 2.1 (it
+ # doesn't report any), and slightly broken in Python 2.2 (it
+ # doesn't report the xml: namespace). So we match up namespaces
+ # with a known list first, and then possibly override them with
+ # the qnames the SAX parser gives us (if indeed it gives us any
+ # at all). Thanks to MatejC for helping me test this and
+ # tirelessly telling me that it didn't work yet.
+ attrsD, self.decls = self.decls, {}
+ if localname=='math' and namespace=='http://www.w3.org/1998/Math/MathML':
+ attrsD['xmlns']=namespace
+ if localname=='svg' and namespace=='http://www.w3.org/2000/svg':
+ attrsD['xmlns']=namespace
+
+ if prefix:
+ localname = prefix.lower() + ':' + localname
+ elif namespace and not qname: #Expat
+ for name,value in self.namespacesInUse.items():
+ if name and value == namespace:
+ localname = name + ':' + localname
+ break
+ if _debug: sys.stderr.write('startElementNS: qname = %s, namespace = %s, givenprefix = %s, prefix = %s, attrs = %s, localname = %s\n' % (qname, namespace, givenprefix, prefix, attrs.items(), localname))
+
+ for (namespace, attrlocalname), attrvalue in attrs._attrs.items():
+ lowernamespace = (namespace or '').lower()
+ prefix = self._matchnamespaces.get(lowernamespace, '')
+ if prefix:
+ attrlocalname = prefix + ':' + attrlocalname
+ attrsD[str(attrlocalname).lower()] = attrvalue
+ for qname in attrs.getQNames():
+ attrsD[str(qname).lower()] = attrs.getValueByQName(qname)
+ self.unknown_starttag(localname, attrsD.items())
+
+ def characters(self, text):
+ self.handle_data(text)
+
+ def endElementNS(self, name, qname):
+ namespace, localname = name
+ lowernamespace = str(namespace or '').lower()
+ if qname and qname.find(':') > 0:
+ givenprefix = qname.split(':')[0]
+ else:
+ givenprefix = ''
+ prefix = self._matchnamespaces.get(lowernamespace, givenprefix)
+ if prefix:
+ localname = prefix + ':' + localname
+ elif namespace and not qname: #Expat
+ for name,value in self.namespacesInUse.items():
+ if name and value == namespace:
+ localname = name + ':' + localname
+ break
+ localname = str(localname).lower()
+ self.unknown_endtag(localname)
+
+ def error(self, exc):
+ self.bozo = 1
+ self.exc = exc
+
+ def fatalError(self, exc):
+ self.error(exc)
+ raise exc
+
+class _BaseHTMLProcessor(sgmllib.SGMLParser):
+ special = re.compile('''[<>'"]''')
+ bare_ampersand = re.compile("&(?!#\d+;|#x[0-9a-fA-F]+;|\w+;)")
+ elements_no_end_tag = [
+ 'area', 'base', 'basefont', 'br', 'col', 'command', 'embed', 'frame',
+ 'hr', 'img', 'input', 'isindex', 'keygen', 'link', 'meta', 'param',
+ 'source', 'track', 'wbr'
+ ]
+
+ def __init__(self, encoding, _type):
+ self.encoding = encoding
+ self._type = _type
+ if _debug: sys.stderr.write('entering BaseHTMLProcessor, encoding=%s\n' % self.encoding)
+ sgmllib.SGMLParser.__init__(self)
+
+ def reset(self):
+ self.pieces = []
+ sgmllib.SGMLParser.reset(self)
+
+ def _shorttag_replace(self, match):
+ tag = match.group(1)
+ if tag in self.elements_no_end_tag:
+ return '<' + tag + ' />'
+ else:
+ return '<' + tag + '>'
+
+ def parse_starttag(self,i):
+ j=sgmllib.SGMLParser.parse_starttag(self, i)
+ if self._type == 'application/xhtml+xml':
+ if j>2 and self.rawdata[j-2:j]=='/>':
+ self.unknown_endtag(self.lasttag)
+ return j
+
+ def feed(self, data):
+ data = re.compile(r'', self._shorttag_replace, data) # bug [ 1399464 ] Bad regexp for _shorttag_replace
+ data = re.sub(r'<([^<>\s]+?)\s*/>', self._shorttag_replace, data)
+ data = data.replace(''', "'")
+ data = data.replace('"', '"')
+ try:
+ bytes
+ if bytes is str:
+ raise NameError
+ self.encoding = self.encoding + '_INVALID_PYTHON_3'
+ except NameError:
+ if self.encoding and type(data) == type(u''):
+ data = data.encode(self.encoding)
+ sgmllib.SGMLParser.feed(self, data)
+ sgmllib.SGMLParser.close(self)
+
+ def normalize_attrs(self, attrs):
+ if not attrs: return attrs
+ # utility method to be called by descendants
+ attrs = dict([(k.lower(), v) for k, v in attrs]).items()
+ attrs = [(k, k in ('rel', 'type') and v.lower() or v) for k, v in attrs]
+ attrs.sort()
+ return attrs
+
+ def unknown_starttag(self, tag, attrs):
+ # called for each start tag
+ # attrs is a list of (attr, value) tuples
+ # e.g. for
, tag='pre', attrs=[('class', 'screen')]
+ if _debug: sys.stderr.write('_BaseHTMLProcessor, unknown_starttag, tag=%s\n' % tag)
+ uattrs = []
+ strattrs=''
+ if attrs:
+ for key, value in attrs:
+ value=value.replace('>','>').replace('<','<').replace('"','"')
+ value = self.bare_ampersand.sub("&", value)
+ # thanks to Kevin Marks for this breathtaking hack to deal with (valid) high-bit attribute values in UTF-8 feeds
+ if type(value) != type(u''):
+ try:
+ value = unicode(value, self.encoding)
+ except:
+ value = unicode(value, 'iso-8859-1')
+ try:
+ # Currently, in Python 3 the key is already a str, and cannot be decoded again
+ uattrs.append((unicode(key, self.encoding), value))
+ except TypeError:
+ uattrs.append((key, value))
+ strattrs = u''.join([u' %s="%s"' % (key, value) for key, value in uattrs])
+ if self.encoding:
+ try:
+ strattrs=strattrs.encode(self.encoding)
+ except:
+ pass
+ if tag in self.elements_no_end_tag:
+ self.pieces.append('<%(tag)s%(strattrs)s />' % locals())
+ else:
+ self.pieces.append('<%(tag)s%(strattrs)s>' % locals())
+
+ def unknown_endtag(self, tag):
+ # called for each end tag, e.g. for , tag will be 'pre'
+ # Reconstruct the original end tag.
+ if tag not in self.elements_no_end_tag:
+ self.pieces.append("" % locals())
+
+ def handle_charref(self, ref):
+ # called for each character reference, e.g. for ' ', ref will be '160'
+ # Reconstruct the original character reference.
+ if ref.startswith('x'):
+ value = unichr(int(ref[1:],16))
+ else:
+ value = unichr(int(ref))
+
+ if value in _cp1252.keys():
+ self.pieces.append('&#%s;' % hex(ord(_cp1252[value]))[1:])
+ else:
+ self.pieces.append('&#%(ref)s;' % locals())
+
+ def handle_entityref(self, ref):
+ # called for each entity reference, e.g. for '©', ref will be 'copy'
+ # Reconstruct the original entity reference.
+ if name2codepoint.has_key(ref):
+ self.pieces.append('&%(ref)s;' % locals())
+ else:
+ self.pieces.append('&%(ref)s' % locals())
+
+ def handle_data(self, text):
+ # called for each block of plain text, i.e. outside of any tag and
+ # not containing any character or entity references
+ # Store the original text verbatim.
+ if _debug: sys.stderr.write('_BaseHTMLProcessor, handle_data, text=%s\n' % text)
+ self.pieces.append(text)
+
+ def handle_comment(self, text):
+ # called for each HTML comment, e.g.
+ # Reconstruct the original comment.
+ self.pieces.append('' % locals())
+
+ def handle_pi(self, text):
+ # called for each processing instruction, e.g.
+ # Reconstruct original processing instruction.
+ self.pieces.append('' % locals())
+
+ def handle_decl(self, text):
+ # called for the DOCTYPE, if present, e.g.
+ #
+ # Reconstruct original DOCTYPE
+ self.pieces.append('' % locals())
+
+ _new_declname_match = re.compile(r'[a-zA-Z][-_.a-zA-Z0-9:]*\s*').match
+ def _scan_name(self, i, declstartpos):
+ rawdata = self.rawdata
+ n = len(rawdata)
+ if i == n:
+ return None, -1
+ m = self._new_declname_match(rawdata, i)
+ if m:
+ s = m.group()
+ name = s.strip()
+ if (i + len(s)) == n:
+ return None, -1 # end of buffer
+ return name.lower(), m.end()
+ else:
+ self.handle_data(rawdata)
+# self.updatepos(declstartpos, i)
+ return None, -1
+
+ def convert_charref(self, name):
+ return '&#%s;' % name
+
+ def convert_entityref(self, name):
+ return '&%s;' % name
+
+ def output(self):
+ '''Return processed HTML as a single string'''
+ return ''.join([str(p) for p in self.pieces])
+
+ def parse_declaration(self, i):
+ try:
+ return sgmllib.SGMLParser.parse_declaration(self, i)
+ except sgmllib.SGMLParseError:
+ # escape the doctype declaration and continue parsing
+ self.handle_data('<')
+ return i+1
+
+class _LooseFeedParser(_FeedParserMixin, _BaseHTMLProcessor):
+ def __init__(self, baseuri, baselang, encoding, entities):
+ sgmllib.SGMLParser.__init__(self)
+ _FeedParserMixin.__init__(self, baseuri, baselang, encoding)
+ _BaseHTMLProcessor.__init__(self, encoding, 'application/xhtml+xml')
+ self.entities=entities
+
+ def decodeEntities(self, element, data):
+ data = data.replace('<', '<')
+ data = data.replace('<', '<')
+ data = data.replace('<', '<')
+ data = data.replace('>', '>')
+ data = data.replace('>', '>')
+ data = data.replace('>', '>')
+ data = data.replace('&', '&')
+ data = data.replace('&', '&')
+ data = data.replace('"', '"')
+ data = data.replace('"', '"')
+ data = data.replace(''', ''')
+ data = data.replace(''', ''')
+ if self.contentparams.has_key('type') and not self.contentparams.get('type', 'xml').endswith('xml'):
+ data = data.replace('<', '<')
+ data = data.replace('>', '>')
+ data = data.replace('&', '&')
+ data = data.replace('"', '"')
+ data = data.replace(''', "'")
+ return data
+
+ def strattrs(self, attrs):
+ return ''.join([' %s="%s"' % (n,v.replace('"','"')) for n,v in attrs])
+
+class _MicroformatsParser:
+ STRING = 1
+ DATE = 2
+ URI = 3
+ NODE = 4
+ EMAIL = 5
+
+ known_xfn_relationships = ['contact', 'acquaintance', 'friend', 'met', 'co-worker', 'coworker', 'colleague', 'co-resident', 'coresident', 'neighbor', 'child', 'parent', 'sibling', 'brother', 'sister', 'spouse', 'wife', 'husband', 'kin', 'relative', 'muse', 'crush', 'date', 'sweetheart', 'me']
+ known_binary_extensions = ['zip','rar','exe','gz','tar','tgz','tbz2','bz2','z','7z','dmg','img','sit','sitx','hqx','deb','rpm','bz2','jar','rar','iso','bin','msi','mp2','mp3','ogg','ogm','mp4','m4v','m4a','avi','wma','wmv']
+
+ def __init__(self, data, baseuri, encoding):
+ self.document = BeautifulSoup.BeautifulSoup(data)
+ self.baseuri = baseuri
+ self.encoding = encoding
+ if type(data) == type(u''):
+ data = data.encode(encoding)
+ self.tags = []
+ self.enclosures = []
+ self.xfn = []
+ self.vcard = None
+
+ def vcardEscape(self, s):
+ if type(s) in (type(''), type(u'')):
+ s = s.replace(',', '\\,').replace(';', '\\;').replace('\n', '\\n')
+ return s
+
+ def vcardFold(self, s):
+ s = re.sub(';+$', '', s)
+ sFolded = ''
+ iMax = 75
+ sPrefix = ''
+ while len(s) > iMax:
+ sFolded += sPrefix + s[:iMax] + '\n'
+ s = s[iMax:]
+ sPrefix = ' '
+ iMax = 74
+ sFolded += sPrefix + s
+ return sFolded
+
+ def normalize(self, s):
+ return re.sub(r'\s+', ' ', s).strip()
+
+ def unique(self, aList):
+ results = []
+ for element in aList:
+ if element not in results:
+ results.append(element)
+ return results
+
+ def toISO8601(self, dt):
+ return time.strftime('%Y-%m-%dT%H:%M:%SZ', dt)
+
+ def getPropertyValue(self, elmRoot, sProperty, iPropertyType=4, bAllowMultiple=0, bAutoEscape=0):
+ all = lambda x: 1
+ sProperty = sProperty.lower()
+ bFound = 0
+ bNormalize = 1
+ propertyMatch = {'class': re.compile(r'\b%s\b' % sProperty)}
+ if bAllowMultiple and (iPropertyType != self.NODE):
+ snapResults = []
+ containers = elmRoot(['ul', 'ol'], propertyMatch)
+ for container in containers:
+ snapResults.extend(container('li'))
+ bFound = (len(snapResults) != 0)
+ if not bFound:
+ snapResults = elmRoot(all, propertyMatch)
+ bFound = (len(snapResults) != 0)
+ if (not bFound) and (sProperty == 'value'):
+ snapResults = elmRoot('pre')
+ bFound = (len(snapResults) != 0)
+ bNormalize = not bFound
+ if not bFound:
+ snapResults = [elmRoot]
+ bFound = (len(snapResults) != 0)
+ arFilter = []
+ if sProperty == 'vcard':
+ snapFilter = elmRoot(all, propertyMatch)
+ for node in snapFilter:
+ if node.findParent(all, propertyMatch):
+ arFilter.append(node)
+ arResults = []
+ for node in snapResults:
+ if node not in arFilter:
+ arResults.append(node)
+ bFound = (len(arResults) != 0)
+ if not bFound:
+ if bAllowMultiple: return []
+ elif iPropertyType == self.STRING: return ''
+ elif iPropertyType == self.DATE: return None
+ elif iPropertyType == self.URI: return ''
+ elif iPropertyType == self.NODE: return None
+ else: return None
+ arValues = []
+ for elmResult in arResults:
+ sValue = None
+ if iPropertyType == self.NODE:
+ if bAllowMultiple:
+ arValues.append(elmResult)
+ continue
+ else:
+ return elmResult
+ sNodeName = elmResult.name.lower()
+ if (iPropertyType == self.EMAIL) and (sNodeName == 'a'):
+ sValue = (elmResult.get('href') or '').split('mailto:').pop().split('?')[0]
+ if sValue:
+ sValue = bNormalize and self.normalize(sValue) or sValue.strip()
+ if (not sValue) and (sNodeName == 'abbr'):
+ sValue = elmResult.get('title')
+ if sValue:
+ sValue = bNormalize and self.normalize(sValue) or sValue.strip()
+ if (not sValue) and (iPropertyType == self.URI):
+ if sNodeName == 'a': sValue = elmResult.get('href')
+ elif sNodeName == 'img': sValue = elmResult.get('src')
+ elif sNodeName == 'object': sValue = elmResult.get('data')
+ if sValue:
+ sValue = bNormalize and self.normalize(sValue) or sValue.strip()
+ if (not sValue) and (sNodeName == 'img'):
+ sValue = elmResult.get('alt')
+ if sValue:
+ sValue = bNormalize and self.normalize(sValue) or sValue.strip()
+ if not sValue:
+ sValue = elmResult.renderContents()
+ sValue = re.sub(r'<\S[^>]*>', '', sValue)
+ sValue = sValue.replace('\r\n', '\n')
+ sValue = sValue.replace('\r', '\n')
+ if sValue:
+ sValue = bNormalize and self.normalize(sValue) or sValue.strip()
+ if not sValue: continue
+ if iPropertyType == self.DATE:
+ sValue = _parse_date_iso8601(sValue)
+ if bAllowMultiple:
+ arValues.append(bAutoEscape and self.vcardEscape(sValue) or sValue)
+ else:
+ return bAutoEscape and self.vcardEscape(sValue) or sValue
+ return arValues
+
+ def findVCards(self, elmRoot, bAgentParsing=0):
+ sVCards = ''
+
+ if not bAgentParsing:
+ arCards = self.getPropertyValue(elmRoot, 'vcard', bAllowMultiple=1)
+ else:
+ arCards = [elmRoot]
+
+ for elmCard in arCards:
+ arLines = []
+
+ def processSingleString(sProperty):
+ sValue = self.getPropertyValue(elmCard, sProperty, self.STRING, bAutoEscape=1).decode(self.encoding)
+ if sValue:
+ arLines.append(self.vcardFold(sProperty.upper() + ':' + sValue))
+ return sValue or u''
+
+ def processSingleURI(sProperty):
+ sValue = self.getPropertyValue(elmCard, sProperty, self.URI)
+ if sValue:
+ sContentType = ''
+ sEncoding = ''
+ sValueKey = ''
+ if sValue.startswith('data:'):
+ sEncoding = ';ENCODING=b'
+ sContentType = sValue.split(';')[0].split('/').pop()
+ sValue = sValue.split(',', 1).pop()
+ else:
+ elmValue = self.getPropertyValue(elmCard, sProperty)
+ if elmValue:
+ if sProperty != 'url':
+ sValueKey = ';VALUE=uri'
+ sContentType = elmValue.get('type', '').strip().split('/').pop().strip()
+ sContentType = sContentType.upper()
+ if sContentType == 'OCTET-STREAM':
+ sContentType = ''
+ if sContentType:
+ sContentType = ';TYPE=' + sContentType.upper()
+ arLines.append(self.vcardFold(sProperty.upper() + sEncoding + sContentType + sValueKey + ':' + sValue))
+
+ def processTypeValue(sProperty, arDefaultType, arForceType=None):
+ arResults = self.getPropertyValue(elmCard, sProperty, bAllowMultiple=1)
+ for elmResult in arResults:
+ arType = self.getPropertyValue(elmResult, 'type', self.STRING, 1, 1)
+ if arForceType:
+ arType = self.unique(arForceType + arType)
+ if not arType:
+ arType = arDefaultType
+ sValue = self.getPropertyValue(elmResult, 'value', self.EMAIL, 0)
+ if sValue:
+ arLines.append(self.vcardFold(sProperty.upper() + ';TYPE=' + ','.join(arType) + ':' + sValue))
+
+ # AGENT
+ # must do this before all other properties because it is destructive
+ # (removes nested class="vcard" nodes so they don't interfere with
+ # this vcard's other properties)
+ arAgent = self.getPropertyValue(elmCard, 'agent', bAllowMultiple=1)
+ for elmAgent in arAgent:
+ if re.compile(r'\bvcard\b').search(elmAgent.get('class')):
+ sAgentValue = self.findVCards(elmAgent, 1) + '\n'
+ sAgentValue = sAgentValue.replace('\n', '\\n')
+ sAgentValue = sAgentValue.replace(';', '\\;')
+ if sAgentValue:
+ arLines.append(self.vcardFold('AGENT:' + sAgentValue))
+ # Completely remove the agent element from the parse tree
+ elmAgent.extract()
+ else:
+ sAgentValue = self.getPropertyValue(elmAgent, 'value', self.URI, bAutoEscape=1);
+ if sAgentValue:
+ arLines.append(self.vcardFold('AGENT;VALUE=uri:' + sAgentValue))
+
+ # FN (full name)
+ sFN = processSingleString('fn')
+
+ # N (name)
+ elmName = self.getPropertyValue(elmCard, 'n')
+ if elmName:
+ sFamilyName = self.getPropertyValue(elmName, 'family-name', self.STRING, bAutoEscape=1)
+ sGivenName = self.getPropertyValue(elmName, 'given-name', self.STRING, bAutoEscape=1)
+ arAdditionalNames = self.getPropertyValue(elmName, 'additional-name', self.STRING, 1, 1) + self.getPropertyValue(elmName, 'additional-names', self.STRING, 1, 1)
+ arHonorificPrefixes = self.getPropertyValue(elmName, 'honorific-prefix', self.STRING, 1, 1) + self.getPropertyValue(elmName, 'honorific-prefixes', self.STRING, 1, 1)
+ arHonorificSuffixes = self.getPropertyValue(elmName, 'honorific-suffix', self.STRING, 1, 1) + self.getPropertyValue(elmName, 'honorific-suffixes', self.STRING, 1, 1)
+ arLines.append(self.vcardFold('N:' + sFamilyName + ';' +
+ sGivenName + ';' +
+ ','.join(arAdditionalNames) + ';' +
+ ','.join(arHonorificPrefixes) + ';' +
+ ','.join(arHonorificSuffixes)))
+ elif sFN:
+ # implied "N" optimization
+ # http://microformats.org/wiki/hcard#Implied_.22N.22_Optimization
+ arNames = self.normalize(sFN).split()
+ if len(arNames) == 2:
+ bFamilyNameFirst = (arNames[0].endswith(',') or
+ len(arNames[1]) == 1 or
+ ((len(arNames[1]) == 2) and (arNames[1].endswith('.'))))
+ if bFamilyNameFirst:
+ arLines.append(self.vcardFold('N:' + arNames[0] + ';' + arNames[1]))
+ else:
+ arLines.append(self.vcardFold('N:' + arNames[1] + ';' + arNames[0]))
+
+ # SORT-STRING
+ sSortString = self.getPropertyValue(elmCard, 'sort-string', self.STRING, bAutoEscape=1)
+ if sSortString:
+ arLines.append(self.vcardFold('SORT-STRING:' + sSortString))
+
+ # NICKNAME
+ arNickname = self.getPropertyValue(elmCard, 'nickname', self.STRING, 1, 1)
+ if arNickname:
+ arLines.append(self.vcardFold('NICKNAME:' + ','.join(arNickname)))
+
+ # PHOTO
+ processSingleURI('photo')
+
+ # BDAY
+ dtBday = self.getPropertyValue(elmCard, 'bday', self.DATE)
+ if dtBday:
+ arLines.append(self.vcardFold('BDAY:' + self.toISO8601(dtBday)))
+
+ # ADR (address)
+ arAdr = self.getPropertyValue(elmCard, 'adr', bAllowMultiple=1)
+ for elmAdr in arAdr:
+ arType = self.getPropertyValue(elmAdr, 'type', self.STRING, 1, 1)
+ if not arType:
+ arType = ['intl','postal','parcel','work'] # default adr types, see RFC 2426 section 3.2.1
+ sPostOfficeBox = self.getPropertyValue(elmAdr, 'post-office-box', self.STRING, 0, 1)
+ sExtendedAddress = self.getPropertyValue(elmAdr, 'extended-address', self.STRING, 0, 1)
+ sStreetAddress = self.getPropertyValue(elmAdr, 'street-address', self.STRING, 0, 1)
+ sLocality = self.getPropertyValue(elmAdr, 'locality', self.STRING, 0, 1)
+ sRegion = self.getPropertyValue(elmAdr, 'region', self.STRING, 0, 1)
+ sPostalCode = self.getPropertyValue(elmAdr, 'postal-code', self.STRING, 0, 1)
+ sCountryName = self.getPropertyValue(elmAdr, 'country-name', self.STRING, 0, 1)
+ arLines.append(self.vcardFold('ADR;TYPE=' + ','.join(arType) + ':' +
+ sPostOfficeBox + ';' +
+ sExtendedAddress + ';' +
+ sStreetAddress + ';' +
+ sLocality + ';' +
+ sRegion + ';' +
+ sPostalCode + ';' +
+ sCountryName))
+
+ # LABEL
+ processTypeValue('label', ['intl','postal','parcel','work'])
+
+ # TEL (phone number)
+ processTypeValue('tel', ['voice'])
+
+ # EMAIL
+ processTypeValue('email', ['internet'], ['internet'])
+
+ # MAILER
+ processSingleString('mailer')
+
+ # TZ (timezone)
+ processSingleString('tz')
+
+ # GEO (geographical information)
+ elmGeo = self.getPropertyValue(elmCard, 'geo')
+ if elmGeo:
+ sLatitude = self.getPropertyValue(elmGeo, 'latitude', self.STRING, 0, 1)
+ sLongitude = self.getPropertyValue(elmGeo, 'longitude', self.STRING, 0, 1)
+ arLines.append(self.vcardFold('GEO:' + sLatitude + ';' + sLongitude))
+
+ # TITLE
+ processSingleString('title')
+
+ # ROLE
+ processSingleString('role')
+
+ # LOGO
+ processSingleURI('logo')
+
+ # ORG (organization)
+ elmOrg = self.getPropertyValue(elmCard, 'org')
+ if elmOrg:
+ sOrganizationName = self.getPropertyValue(elmOrg, 'organization-name', self.STRING, 0, 1)
+ if not sOrganizationName:
+ # implied "organization-name" optimization
+ # http://microformats.org/wiki/hcard#Implied_.22organization-name.22_Optimization
+ sOrganizationName = self.getPropertyValue(elmCard, 'org', self.STRING, 0, 1)
+ if sOrganizationName:
+ arLines.append(self.vcardFold('ORG:' + sOrganizationName))
+ else:
+ arOrganizationUnit = self.getPropertyValue(elmOrg, 'organization-unit', self.STRING, 1, 1)
+ arLines.append(self.vcardFold('ORG:' + sOrganizationName + ';' + ';'.join(arOrganizationUnit)))
+
+ # CATEGORY
+ arCategory = self.getPropertyValue(elmCard, 'category', self.STRING, 1, 1) + self.getPropertyValue(elmCard, 'categories', self.STRING, 1, 1)
+ if arCategory:
+ arLines.append(self.vcardFold('CATEGORIES:' + ','.join(arCategory)))
+
+ # NOTE
+ processSingleString('note')
+
+ # REV
+ processSingleString('rev')
+
+ # SOUND
+ processSingleURI('sound')
+
+ # UID
+ processSingleString('uid')
+
+ # URL
+ processSingleURI('url')
+
+ # CLASS
+ processSingleString('class')
+
+ # KEY
+ processSingleURI('key')
+
+ if arLines:
+ arLines = [u'BEGIN:vCard',u'VERSION:3.0'] + arLines + [u'END:vCard']
+ sVCards += u'\n'.join(arLines) + u'\n'
+
+ return sVCards.strip()
+
+ def isProbablyDownloadable(self, elm):
+ attrsD = elm.attrMap
+ if not attrsD.has_key('href'): return 0
+ linktype = attrsD.get('type', '').strip()
+ if linktype.startswith('audio/') or \
+ linktype.startswith('video/') or \
+ (linktype.startswith('application/') and not linktype.endswith('xml')):
+ return 1
+ path = urlparse.urlparse(attrsD['href'])[2]
+ if path.find('.') == -1: return 0
+ fileext = path.split('.').pop().lower()
+ return fileext in self.known_binary_extensions
+
+ def findTags(self):
+ all = lambda x: 1
+ for elm in self.document(all, {'rel': re.compile(r'\btag\b')}):
+ href = elm.get('href')
+ if not href: continue
+ urlscheme, domain, path, params, query, fragment = \
+ urlparse.urlparse(_urljoin(self.baseuri, href))
+ segments = path.split('/')
+ tag = segments.pop()
+ if not tag:
+ tag = segments.pop()
+ tagscheme = urlparse.urlunparse((urlscheme, domain, '/'.join(segments), '', '', ''))
+ if not tagscheme.endswith('/'):
+ tagscheme += '/'
+ self.tags.append(FeedParserDict({"term": tag, "scheme": tagscheme, "label": elm.string or ''}))
+
+ def findEnclosures(self):
+ all = lambda x: 1
+ enclosure_match = re.compile(r'\benclosure\b')
+ for elm in self.document(all, {'href': re.compile(r'.+')}):
+ if not enclosure_match.search(elm.get('rel', '')) and not self.isProbablyDownloadable(elm): continue
+ if elm.attrMap not in self.enclosures:
+ self.enclosures.append(elm.attrMap)
+ if elm.string and not elm.get('title'):
+ self.enclosures[-1]['title'] = elm.string
+
+ def findXFN(self):
+ all = lambda x: 1
+ for elm in self.document(all, {'rel': re.compile('.+'), 'href': re.compile('.+')}):
+ rels = elm.get('rel', '').split()
+ xfn_rels = []
+ for rel in rels:
+ if rel in self.known_xfn_relationships:
+ xfn_rels.append(rel)
+ if xfn_rels:
+ self.xfn.append({"relationships": xfn_rels, "href": elm.get('href', ''), "name": elm.string})
+
+def _parseMicroformats(htmlSource, baseURI, encoding):
+ if not BeautifulSoup: return
+ if _debug: sys.stderr.write('entering _parseMicroformats\n')
+ try:
+ p = _MicroformatsParser(htmlSource, baseURI, encoding)
+ except UnicodeEncodeError:
+ # sgmllib throws this exception when performing lookups of tags
+ # with non-ASCII characters in them.
+ return
+ p.vcard = p.findVCards(p.document)
+ p.findTags()
+ p.findEnclosures()
+ p.findXFN()
+ return {"tags": p.tags, "enclosures": p.enclosures, "xfn": p.xfn, "vcard": p.vcard}
+
+class _RelativeURIResolver(_BaseHTMLProcessor):
+ relative_uris = [('a', 'href'),
+ ('applet', 'codebase'),
+ ('area', 'href'),
+ ('blockquote', 'cite'),
+ ('body', 'background'),
+ ('del', 'cite'),
+ ('form', 'action'),
+ ('frame', 'longdesc'),
+ ('frame', 'src'),
+ ('iframe', 'longdesc'),
+ ('iframe', 'src'),
+ ('head', 'profile'),
+ ('img', 'longdesc'),
+ ('img', 'src'),
+ ('img', 'usemap'),
+ ('input', 'src'),
+ ('input', 'usemap'),
+ ('ins', 'cite'),
+ ('link', 'href'),
+ ('object', 'classid'),
+ ('object', 'codebase'),
+ ('object', 'data'),
+ ('object', 'usemap'),
+ ('q', 'cite'),
+ ('script', 'src')]
+
+ def __init__(self, baseuri, encoding, _type):
+ _BaseHTMLProcessor.__init__(self, encoding, _type)
+ self.baseuri = baseuri
+
+ def resolveURI(self, uri):
+ return _makeSafeAbsoluteURI(_urljoin(self.baseuri, uri.strip()))
+
+ def unknown_starttag(self, tag, attrs):
+ if _debug:
+ sys.stderr.write('tag: [%s] with attributes: [%s]\n' % (tag, str(attrs)))
+ attrs = self.normalize_attrs(attrs)
+ attrs = [(key, ((tag, key) in self.relative_uris) and self.resolveURI(value) or value) for key, value in attrs]
+ _BaseHTMLProcessor.unknown_starttag(self, tag, attrs)
+
+def _resolveRelativeURIs(htmlSource, baseURI, encoding, _type):
+ if _debug:
+ sys.stderr.write('entering _resolveRelativeURIs\n')
+
+ p = _RelativeURIResolver(baseURI, encoding, _type)
+ p.feed(htmlSource)
+ return p.output()
+
+def _makeSafeAbsoluteURI(base, rel=None):
+ # bail if ACCEPTABLE_URI_SCHEMES is empty
+ if not ACCEPTABLE_URI_SCHEMES:
+ return _urljoin(base, rel or u'')
+ if not base:
+ return rel or u''
+ if not rel:
+ scheme = urlparse.urlparse(base)[0]
+ if not scheme or scheme in ACCEPTABLE_URI_SCHEMES:
+ return base
+ return u''
+ uri = _urljoin(base, rel)
+ if uri.strip().split(':', 1)[0] not in ACCEPTABLE_URI_SCHEMES:
+ return u''
+ return uri
+
+class _HTMLSanitizer(_BaseHTMLProcessor):
+ acceptable_elements = ['a', 'abbr', 'acronym', 'address', 'area',
+ 'article', 'aside', 'audio', 'b', 'big', 'blockquote', 'br', 'button',
+ 'canvas', 'caption', 'center', 'cite', 'code', 'col', 'colgroup',
+ 'command', 'datagrid', 'datalist', 'dd', 'del', 'details', 'dfn',
+ 'dialog', 'dir', 'div', 'dl', 'dt', 'em', 'event-source', 'fieldset',
+ 'figcaption', 'figure', 'footer', 'font', 'form', 'header', 'h1',
+ 'h2', 'h3', 'h4', 'h5', 'h6', 'hr', 'i', 'img', 'input', 'ins',
+ 'keygen', 'kbd', 'label', 'legend', 'li', 'm', 'map', 'menu', 'meter',
+ 'multicol', 'nav', 'nextid', 'ol', 'output', 'optgroup', 'option',
+ 'p', 'pre', 'progress', 'q', 's', 'samp', 'section', 'select',
+ 'small', 'sound', 'source', 'spacer', 'span', 'strike', 'strong',
+ 'sub', 'sup', 'table', 'tbody', 'td', 'textarea', 'time', 'tfoot',
+ 'th', 'thead', 'tr', 'tt', 'u', 'ul', 'var', 'video', 'noscript']
+
+ acceptable_attributes = ['abbr', 'accept', 'accept-charset', 'accesskey',
+ 'action', 'align', 'alt', 'autocomplete', 'autofocus', 'axis',
+ 'background', 'balance', 'bgcolor', 'bgproperties', 'border',
+ 'bordercolor', 'bordercolordark', 'bordercolorlight', 'bottompadding',
+ 'cellpadding', 'cellspacing', 'ch', 'challenge', 'char', 'charoff',
+ 'choff', 'charset', 'checked', 'cite', 'class', 'clear', 'color', 'cols',
+ 'colspan', 'compact', 'contenteditable', 'controls', 'coords', 'data',
+ 'datafld', 'datapagesize', 'datasrc', 'datetime', 'default', 'delay',
+ 'dir', 'disabled', 'draggable', 'dynsrc', 'enctype', 'end', 'face', 'for',
+ 'form', 'frame', 'galleryimg', 'gutter', 'headers', 'height', 'hidefocus',
+ 'hidden', 'high', 'href', 'hreflang', 'hspace', 'icon', 'id', 'inputmode',
+ 'ismap', 'keytype', 'label', 'leftspacing', 'lang', 'list', 'longdesc',
+ 'loop', 'loopcount', 'loopend', 'loopstart', 'low', 'lowsrc', 'max',
+ 'maxlength', 'media', 'method', 'min', 'multiple', 'name', 'nohref',
+ 'noshade', 'nowrap', 'open', 'optimum', 'pattern', 'ping', 'point-size',
+ 'prompt', 'pqg', 'radiogroup', 'readonly', 'rel', 'repeat-max',
+ 'repeat-min', 'replace', 'required', 'rev', 'rightspacing', 'rows',
+ 'rowspan', 'rules', 'scope', 'selected', 'shape', 'size', 'span', 'src',
+ 'start', 'step', 'summary', 'suppress', 'tabindex', 'target', 'template',
+ 'title', 'toppadding', 'type', 'unselectable', 'usemap', 'urn', 'valign',
+ 'value', 'variable', 'volume', 'vspace', 'vrml', 'width', 'wrap',
+ 'xml:lang']
+
+ unacceptable_elements_with_end_tag = ['script', 'applet', 'style']
+
+ acceptable_css_properties = ['azimuth', 'background-color',
+ 'border-bottom-color', 'border-collapse', 'border-color',
+ 'border-left-color', 'border-right-color', 'border-top-color', 'clear',
+ 'color', 'cursor', 'direction', 'display', 'elevation', 'float', 'font',
+ 'font-family', 'font-size', 'font-style', 'font-variant', 'font-weight',
+ 'height', 'letter-spacing', 'line-height', 'overflow', 'pause',
+ 'pause-after', 'pause-before', 'pitch', 'pitch-range', 'richness',
+ 'speak', 'speak-header', 'speak-numeral', 'speak-punctuation',
+ 'speech-rate', 'stress', 'text-align', 'text-decoration', 'text-indent',
+ 'unicode-bidi', 'vertical-align', 'voice-family', 'volume',
+ 'white-space', 'width']
+
+ # survey of common keywords found in feeds
+ acceptable_css_keywords = ['auto', 'aqua', 'black', 'block', 'blue',
+ 'bold', 'both', 'bottom', 'brown', 'center', 'collapse', 'dashed',
+ 'dotted', 'fuchsia', 'gray', 'green', '!important', 'italic', 'left',
+ 'lime', 'maroon', 'medium', 'none', 'navy', 'normal', 'nowrap', 'olive',
+ 'pointer', 'purple', 'red', 'right', 'solid', 'silver', 'teal', 'top',
+ 'transparent', 'underline', 'white', 'yellow']
+
+ valid_css_values = re.compile('^(#[0-9a-f]+|rgb\(\d+%?,\d*%?,?\d*%?\)?|' +
+ '\d{0,2}\.?\d{0,2}(cm|em|ex|in|mm|pc|pt|px|%|,|\))?)$')
+
+ mathml_elements = ['annotation', 'annotation-xml', 'maction', 'math',
+ 'merror', 'mfenced', 'mfrac', 'mi', 'mmultiscripts', 'mn', 'mo', 'mover', 'mpadded',
+ 'mphantom', 'mprescripts', 'mroot', 'mrow', 'mspace', 'msqrt', 'mstyle',
+ 'msub', 'msubsup', 'msup', 'mtable', 'mtd', 'mtext', 'mtr', 'munder',
+ 'munderover', 'none', 'semantics']
+
+ mathml_attributes = ['actiontype', 'align', 'columnalign', 'columnalign',
+ 'columnalign', 'close', 'columnlines', 'columnspacing', 'columnspan', 'depth',
+ 'display', 'displaystyle', 'encoding', 'equalcolumns', 'equalrows',
+ 'fence', 'fontstyle', 'fontweight', 'frame', 'height', 'linethickness',
+ 'lspace', 'mathbackground', 'mathcolor', 'mathvariant', 'mathvariant',
+ 'maxsize', 'minsize', 'open', 'other', 'rowalign', 'rowalign', 'rowalign',
+ 'rowlines', 'rowspacing', 'rowspan', 'rspace', 'scriptlevel', 'selection',
+ 'separator', 'separators', 'stretchy', 'width', 'width', 'xlink:href',
+ 'xlink:show', 'xlink:type', 'xmlns', 'xmlns:xlink']
+
+ # svgtiny - foreignObject + linearGradient + radialGradient + stop
+ svg_elements = ['a', 'animate', 'animateColor', 'animateMotion',
+ 'animateTransform', 'circle', 'defs', 'desc', 'ellipse', 'foreignObject',
+ 'font-face', 'font-face-name', 'font-face-src', 'g', 'glyph', 'hkern',
+ 'linearGradient', 'line', 'marker', 'metadata', 'missing-glyph', 'mpath',
+ 'path', 'polygon', 'polyline', 'radialGradient', 'rect', 'set', 'stop',
+ 'svg', 'switch', 'text', 'title', 'tspan', 'use']
+
+ # svgtiny + class + opacity + offset + xmlns + xmlns:xlink
+ svg_attributes = ['accent-height', 'accumulate', 'additive', 'alphabetic',
+ 'arabic-form', 'ascent', 'attributeName', 'attributeType',
+ 'baseProfile', 'bbox', 'begin', 'by', 'calcMode', 'cap-height',
+ 'class', 'color', 'color-rendering', 'content', 'cx', 'cy', 'd', 'dx',
+ 'dy', 'descent', 'display', 'dur', 'end', 'fill', 'fill-opacity',
+ 'fill-rule', 'font-family', 'font-size', 'font-stretch', 'font-style',
+ 'font-variant', 'font-weight', 'from', 'fx', 'fy', 'g1', 'g2',
+ 'glyph-name', 'gradientUnits', 'hanging', 'height', 'horiz-adv-x',
+ 'horiz-origin-x', 'id', 'ideographic', 'k', 'keyPoints', 'keySplines',
+ 'keyTimes', 'lang', 'mathematical', 'marker-end', 'marker-mid',
+ 'marker-start', 'markerHeight', 'markerUnits', 'markerWidth', 'max',
+ 'min', 'name', 'offset', 'opacity', 'orient', 'origin',
+ 'overline-position', 'overline-thickness', 'panose-1', 'path',
+ 'pathLength', 'points', 'preserveAspectRatio', 'r', 'refX', 'refY',
+ 'repeatCount', 'repeatDur', 'requiredExtensions', 'requiredFeatures',
+ 'restart', 'rotate', 'rx', 'ry', 'slope', 'stemh', 'stemv',
+ 'stop-color', 'stop-opacity', 'strikethrough-position',
+ 'strikethrough-thickness', 'stroke', 'stroke-dasharray',
+ 'stroke-dashoffset', 'stroke-linecap', 'stroke-linejoin',
+ 'stroke-miterlimit', 'stroke-opacity', 'stroke-width', 'systemLanguage',
+ 'target', 'text-anchor', 'to', 'transform', 'type', 'u1', 'u2',
+ 'underline-position', 'underline-thickness', 'unicode', 'unicode-range',
+ 'units-per-em', 'values', 'version', 'viewBox', 'visibility', 'width',
+ 'widths', 'x', 'x-height', 'x1', 'x2', 'xlink:actuate', 'xlink:arcrole',
+ 'xlink:href', 'xlink:role', 'xlink:show', 'xlink:title', 'xlink:type',
+ 'xml:base', 'xml:lang', 'xml:space', 'xmlns', 'xmlns:xlink', 'y', 'y1',
+ 'y2', 'zoomAndPan']
+
+ svg_attr_map = None
+ svg_elem_map = None
+
+ acceptable_svg_properties = [ 'fill', 'fill-opacity', 'fill-rule',
+ 'stroke', 'stroke-width', 'stroke-linecap', 'stroke-linejoin',
+ 'stroke-opacity']
+
+ def reset(self):
+ _BaseHTMLProcessor.reset(self)
+ self.unacceptablestack = 0
+ self.mathmlOK = 0
+ self.svgOK = 0
+
+ def unknown_starttag(self, tag, attrs):
+ acceptable_attributes = self.acceptable_attributes
+ keymap = {}
+ if not tag in self.acceptable_elements or self.svgOK:
+ if tag in self.unacceptable_elements_with_end_tag:
+ self.unacceptablestack += 1
+
+ # add implicit namespaces to html5 inline svg/mathml
+ if self._type.endswith('html'):
+ if not dict(attrs).get('xmlns'):
+ if tag=='svg':
+ attrs.append( ('xmlns','http://www.w3.org/2000/svg') )
+ if tag=='math':
+ attrs.append( ('xmlns','http://www.w3.org/1998/Math/MathML') )
+
+ # not otherwise acceptable, perhaps it is MathML or SVG?
+ if tag=='math' and ('xmlns','http://www.w3.org/1998/Math/MathML') in attrs:
+ self.mathmlOK += 1
+ if tag=='svg' and ('xmlns','http://www.w3.org/2000/svg') in attrs:
+ self.svgOK += 1
+
+ # chose acceptable attributes based on tag class, else bail
+ if self.mathmlOK and tag in self.mathml_elements:
+ acceptable_attributes = self.mathml_attributes
+ elif self.svgOK and tag in self.svg_elements:
+ # for most vocabularies, lowercasing is a good idea. Many
+ # svg elements, however, are camel case
+ if not self.svg_attr_map:
+ lower=[attr.lower() for attr in self.svg_attributes]
+ mix=[a for a in self.svg_attributes if a not in lower]
+ self.svg_attributes = lower
+ self.svg_attr_map = dict([(a.lower(),a) for a in mix])
+
+ lower=[attr.lower() for attr in self.svg_elements]
+ mix=[a for a in self.svg_elements if a not in lower]
+ self.svg_elements = lower
+ self.svg_elem_map = dict([(a.lower(),a) for a in mix])
+ acceptable_attributes = self.svg_attributes
+ tag = self.svg_elem_map.get(tag,tag)
+ keymap = self.svg_attr_map
+ elif not tag in self.acceptable_elements:
+ return
+
+ # declare xlink namespace, if needed
+ if self.mathmlOK or self.svgOK:
+ if filter(lambda (n,v): n.startswith('xlink:'),attrs):
+ if not ('xmlns:xlink','http://www.w3.org/1999/xlink') in attrs:
+ attrs.append(('xmlns:xlink','http://www.w3.org/1999/xlink'))
+
+ clean_attrs = []
+ for key, value in self.normalize_attrs(attrs):
+ if key in acceptable_attributes:
+ key=keymap.get(key,key)
+ # make sure the uri uses an acceptable uri scheme
+ if key == u'href':
+ value = _makeSafeAbsoluteURI(value)
+ clean_attrs.append((key,value))
+ elif key=='style':
+ clean_value = self.sanitize_style(value)
+ if clean_value: clean_attrs.append((key,clean_value))
+ _BaseHTMLProcessor.unknown_starttag(self, tag, clean_attrs)
+
+ def unknown_endtag(self, tag):
+ if not tag in self.acceptable_elements:
+ if tag in self.unacceptable_elements_with_end_tag:
+ self.unacceptablestack -= 1
+ if self.mathmlOK and tag in self.mathml_elements:
+ if tag == 'math' and self.mathmlOK: self.mathmlOK -= 1
+ elif self.svgOK and tag in self.svg_elements:
+ tag = self.svg_elem_map.get(tag,tag)
+ if tag == 'svg' and self.svgOK: self.svgOK -= 1
+ else:
+ return
+ _BaseHTMLProcessor.unknown_endtag(self, tag)
+
+ def handle_pi(self, text):
+ pass
+
+ def handle_decl(self, text):
+ pass
+
+ def handle_data(self, text):
+ if not self.unacceptablestack:
+ _BaseHTMLProcessor.handle_data(self, text)
+
+ def sanitize_style(self, style):
+ # disallow urls
+ style=re.compile('url\s*\(\s*[^\s)]+?\s*\)\s*').sub(' ',style)
+
+ # gauntlet
+ if not re.match("""^([:,;#%.\sa-zA-Z0-9!]|\w-\w|'[\s\w]+'|"[\s\w]+"|\([\d,\s]+\))*$""", style): return ''
+ # This replaced a regexp that used re.match and was prone to pathological back-tracking.
+ if re.sub("\s*[-\w]+\s*:\s*[^:;]*;?", '', style).strip(): return ''
+
+ clean = []
+ for prop,value in re.findall("([-\w]+)\s*:\s*([^:;]*)",style):
+ if not value: continue
+ if prop.lower() in self.acceptable_css_properties:
+ clean.append(prop + ': ' + value + ';')
+ elif prop.split('-')[0].lower() in ['background','border','margin','padding']:
+ for keyword in value.split():
+ if not keyword in self.acceptable_css_keywords and \
+ not self.valid_css_values.match(keyword):
+ break
+ else:
+ clean.append(prop + ': ' + value + ';')
+ elif self.svgOK and prop.lower() in self.acceptable_svg_properties:
+ clean.append(prop + ': ' + value + ';')
+
+ return ' '.join(clean)
+
+ def parse_comment(self, i, report=1):
+ ret = _BaseHTMLProcessor.parse_comment(self, i, report)
+ if ret >= 0:
+ return ret
+ # if ret == -1, this may be a malicious attempt to circumvent
+ # sanitization, or a page-destroying unclosed comment
+ match = re.compile(r'--[^>]*>').search(self.rawdata, i+4)
+ if match:
+ return match.end()
+ # unclosed comment; deliberately fail to handle_data()
+ return len(self.rawdata)
+
+
+def _sanitizeHTML(htmlSource, encoding, _type):
+ p = _HTMLSanitizer(encoding, _type)
+ htmlSource = htmlSource.replace(''):
+ data = data.split('>', 1)[1]
+ if data.count('= '2.3.3'
+ assert base64 != None
+ user, passw = _base64decode(req.headers['Authorization'].split(' ')[1]).split(':')
+ realm = re.findall('realm="([^"]*)"', headers['WWW-Authenticate'])[0]
+ self.add_password(realm, host, user, passw)
+ retry = self.http_error_auth_reqed('www-authenticate', host, req, headers)
+ self.reset_retry_count()
+ return retry
+ except:
+ return self.http_error_default(req, fp, code, msg, headers)
+
+def _open_resource(url_file_stream_or_string, etag, modified, agent, referrer, handlers, request_headers):
+ """URL, filename, or string --> stream
+
+ This function lets you define parsers that take any input source
+ (URL, pathname to local or network file, or actual data as a string)
+ and deal with it in a uniform manner. Returned object is guaranteed
+ to have all the basic stdio read methods (read, readline, readlines).
+ Just .close() the object when you're done with it.
+
+ If the etag argument is supplied, it will be used as the value of an
+ If-None-Match request header.
+
+ If the modified argument is supplied, it can be a tuple of 9 integers
+ (as returned by gmtime() in the standard Python time module) or a date
+ string in any format supported by feedparser. Regardless, it MUST
+ be in GMT (Greenwich Mean Time). It will be reformatted into an
+ RFC 1123-compliant date and used as the value of an If-Modified-Since
+ request header.
+
+ If the agent argument is supplied, it will be used as the value of a
+ User-Agent request header.
+
+ If the referrer argument is supplied, it will be used as the value of a
+ Referer[sic] request header.
+
+ If handlers is supplied, it is a list of handlers used to build a
+ urllib2 opener.
+
+ if request_headers is supplied it is a dictionary of HTTP request headers
+ that will override the values generated by FeedParser.
+ """
+
+ if hasattr(url_file_stream_or_string, 'read'):
+ return url_file_stream_or_string
+
+ if url_file_stream_or_string == '-':
+ return sys.stdin
+
+ if urlparse.urlparse(url_file_stream_or_string)[0] in ('http', 'https', 'ftp', 'file', 'feed'):
+ # Deal with the feed URI scheme
+ if url_file_stream_or_string.startswith('feed:http'):
+ url_file_stream_or_string = url_file_stream_or_string[5:]
+ elif url_file_stream_or_string.startswith('feed:'):
+ url_file_stream_or_string = 'http:' + url_file_stream_or_string[5:]
+ if not agent:
+ agent = USER_AGENT
+ # test for inline user:password for basic auth
+ auth = None
+ if base64:
+ urltype, rest = urllib.splittype(url_file_stream_or_string)
+ realhost, rest = urllib.splithost(rest)
+ if realhost:
+ user_passwd, realhost = urllib.splituser(realhost)
+ if user_passwd:
+ url_file_stream_or_string = '%s://%s%s' % (urltype, realhost, rest)
+ auth = base64.standard_b64encode(user_passwd).strip()
+
+ # iri support
+ try:
+ if isinstance(url_file_stream_or_string,unicode):
+ url_file_stream_or_string = url_file_stream_or_string.encode('idna').decode('utf-8')
+ else:
+ url_file_stream_or_string = url_file_stream_or_string.decode('utf-8').encode('idna').decode('utf-8')
+ except:
+ pass
+
+ # try to open with urllib2 (to use optional headers)
+ request = _build_urllib2_request(url_file_stream_or_string, agent, etag, modified, referrer, auth, request_headers)
+ opener = apply(urllib2.build_opener, tuple(handlers + [_FeedURLHandler()]))
+ opener.addheaders = [] # RMK - must clear so we only send our custom User-Agent
+ try:
+ return opener.open(request)
+ finally:
+ opener.close() # JohnD
+
+ # try to open with native open function (if url_file_stream_or_string is a filename)
+ try:
+ return open(url_file_stream_or_string, 'rb')
+ except:
+ pass
+
+ # treat url_file_stream_or_string as string
+ return _StringIO(str(url_file_stream_or_string))
+
+def _build_urllib2_request(url, agent, etag, modified, referrer, auth, request_headers):
+ request = urllib2.Request(url)
+ request.add_header('User-Agent', agent)
+ if etag:
+ request.add_header('If-None-Match', etag)
+ if type(modified) == type(''):
+ modified = _parse_date(modified)
+ elif isinstance(modified, datetime.datetime):
+ modified = modified.utctimetuple()
+ if modified:
+ # format into an RFC 1123-compliant timestamp. We can't use
+ # time.strftime() since the %a and %b directives can be affected
+ # by the current locale, but RFC 2616 states that dates must be
+ # in English.
+ short_weekdays = ['Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun']
+ months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec']
+ request.add_header('If-Modified-Since', '%s, %02d %s %04d %02d:%02d:%02d GMT' % (short_weekdays[modified[6]], modified[2], months[modified[1] - 1], modified[0], modified[3], modified[4], modified[5]))
+ if referrer:
+ request.add_header('Referer', referrer)
+ if gzip and zlib:
+ request.add_header('Accept-encoding', 'gzip, deflate')
+ elif gzip:
+ request.add_header('Accept-encoding', 'gzip')
+ elif zlib:
+ request.add_header('Accept-encoding', 'deflate')
+ else:
+ request.add_header('Accept-encoding', '')
+ if auth:
+ request.add_header('Authorization', 'Basic %s' % auth)
+ if ACCEPT_HEADER:
+ request.add_header('Accept', ACCEPT_HEADER)
+ # use this for whatever -- cookies, special headers, etc
+ # [('Cookie','Something'),('x-special-header','Another Value')]
+ for header_name, header_value in request_headers.items():
+ request.add_header(header_name, header_value)
+ request.add_header('A-IM', 'feed') # RFC 3229 support
+ return request
+
+_date_handlers = []
+def registerDateHandler(func):
+ '''Register a date handler function (takes string, returns 9-tuple date in GMT)'''
+ _date_handlers.insert(0, func)
+
+# ISO-8601 date parsing routines written by Fazal Majid.
+# The ISO 8601 standard is very convoluted and irregular - a full ISO 8601
+# parser is beyond the scope of feedparser and would be a worthwhile addition
+# to the Python library.
+# A single regular expression cannot parse ISO 8601 date formats into groups
+# as the standard is highly irregular (for instance is 030104 2003-01-04 or
+# 0301-04-01), so we use templates instead.
+# Please note the order in templates is significant because we need a
+# greedy match.
+_iso8601_tmpl = ['YYYY-?MM-?DD', 'YYYY-0MM?-?DD', 'YYYY-MM', 'YYYY-?OOO',
+ 'YY-?MM-?DD', 'YY-?OOO', 'YYYY',
+ '-YY-?MM', '-OOO', '-YY',
+ '--MM-?DD', '--MM',
+ '---DD',
+ 'CC', '']
+_iso8601_re = [
+ tmpl.replace(
+ 'YYYY', r'(?P
\d{4})').replace(
+ 'YY', r'(?P\d\d)').replace(
+ 'MM', r'(?P[01]\d)').replace(
+ 'DD', r'(?P[0123]\d)').replace(
+ 'OOO', r'(?P[0123]\d\d)').replace(
+ 'CC', r'(?P\d\d$)')
+ + r'(T?(?P\d{2}):(?P\d{2})'
+ + r'(:(?P\d{2}))?'
+ + r'(\.(?P\d+))?'
+ + r'(?P[+-](?P\d{2})(:(?P\d{2}))?|Z)?)?'
+ for tmpl in _iso8601_tmpl]
+try:
+ del tmpl
+except NameError:
+ pass
+_iso8601_matches = [re.compile(regex).match for regex in _iso8601_re]
+try:
+ del regex
+except NameError:
+ pass
+def _parse_date_iso8601(dateString):
+ '''Parse a variety of ISO-8601-compatible formats like 20040105'''
+ m = None
+ for _iso8601_match in _iso8601_matches:
+ m = _iso8601_match(dateString)
+ if m: break
+ if not m: return
+ if m.span() == (0, 0): return
+ params = m.groupdict()
+ ordinal = params.get('ordinal', 0)
+ if ordinal:
+ ordinal = int(ordinal)
+ else:
+ ordinal = 0
+ year = params.get('year', '--')
+ if not year or year == '--':
+ year = time.gmtime()[0]
+ elif len(year) == 2:
+ # ISO 8601 assumes current century, i.e. 93 -> 2093, NOT 1993
+ year = 100 * int(time.gmtime()[0] / 100) + int(year)
+ else:
+ year = int(year)
+ month = params.get('month', '-')
+ if not month or month == '-':
+ # ordinals are NOT normalized by mktime, we simulate them
+ # by setting month=1, day=ordinal
+ if ordinal:
+ month = 1
+ else:
+ month = time.gmtime()[1]
+ month = int(month)
+ day = params.get('day', 0)
+ if not day:
+ # see above
+ if ordinal:
+ day = ordinal
+ elif params.get('century', 0) or \
+ params.get('year', 0) or params.get('month', 0):
+ day = 1
+ else:
+ day = time.gmtime()[2]
+ else:
+ day = int(day)
+ # special case of the century - is the first year of the 21st century
+ # 2000 or 2001 ? The debate goes on...
+ if 'century' in params.keys():
+ year = (int(params['century']) - 1) * 100 + 1
+ # in ISO 8601 most fields are optional
+ for field in ['hour', 'minute', 'second', 'tzhour', 'tzmin']:
+ if not params.get(field, None):
+ params[field] = 0
+ hour = int(params.get('hour', 0))
+ minute = int(params.get('minute', 0))
+ second = int(float(params.get('second', 0)))
+ # weekday is normalized by mktime(), we can ignore it
+ weekday = 0
+ daylight_savings_flag = -1
+ tm = [year, month, day, hour, minute, second, weekday,
+ ordinal, daylight_savings_flag]
+ # ISO 8601 time zone adjustments
+ tz = params.get('tz')
+ if tz and tz != 'Z':
+ if tz[0] == '-':
+ tm[3] += int(params.get('tzhour', 0))
+ tm[4] += int(params.get('tzmin', 0))
+ elif tz[0] == '+':
+ tm[3] -= int(params.get('tzhour', 0))
+ tm[4] -= int(params.get('tzmin', 0))
+ else:
+ return None
+ # Python's time.mktime() is a wrapper around the ANSI C mktime(3c)
+ # which is guaranteed to normalize d/m/y/h/m/s.
+ # Many implementations have bugs, but we'll pretend they don't.
+ return time.localtime(time.mktime(tuple(tm)))
+registerDateHandler(_parse_date_iso8601)
+
+# 8-bit date handling routines written by ytrewq1.
+_korean_year = u'\ub144' # b3e2 in euc-kr
+_korean_month = u'\uc6d4' # bff9 in euc-kr
+_korean_day = u'\uc77c' # c0cf in euc-kr
+_korean_am = u'\uc624\uc804' # bfc0 c0fc in euc-kr
+_korean_pm = u'\uc624\ud6c4' # bfc0 c8c4 in euc-kr
+
+_korean_onblog_date_re = \
+ re.compile('(\d{4})%s\s+(\d{2})%s\s+(\d{2})%s\s+(\d{2}):(\d{2}):(\d{2})' % \
+ (_korean_year, _korean_month, _korean_day))
+_korean_nate_date_re = \
+ re.compile(u'(\d{4})-(\d{2})-(\d{2})\s+(%s|%s)\s+(\d{,2}):(\d{,2}):(\d{,2})' % \
+ (_korean_am, _korean_pm))
+def _parse_date_onblog(dateString):
+ '''Parse a string according to the OnBlog 8-bit date format'''
+ m = _korean_onblog_date_re.match(dateString)
+ if not m: return
+ w3dtfdate = '%(year)s-%(month)s-%(day)sT%(hour)s:%(minute)s:%(second)s%(zonediff)s' % \
+ {'year': m.group(1), 'month': m.group(2), 'day': m.group(3),\
+ 'hour': m.group(4), 'minute': m.group(5), 'second': m.group(6),\
+ 'zonediff': '+09:00'}
+ if _debug: sys.stderr.write('OnBlog date parsed as: %s\n' % w3dtfdate)
+ return _parse_date_w3dtf(w3dtfdate)
+registerDateHandler(_parse_date_onblog)
+
+def _parse_date_nate(dateString):
+ '''Parse a string according to the Nate 8-bit date format'''
+ m = _korean_nate_date_re.match(dateString)
+ if not m: return
+ hour = int(m.group(5))
+ ampm = m.group(4)
+ if (ampm == _korean_pm):
+ hour += 12
+ hour = str(hour)
+ if len(hour) == 1:
+ hour = '0' + hour
+ w3dtfdate = '%(year)s-%(month)s-%(day)sT%(hour)s:%(minute)s:%(second)s%(zonediff)s' % \
+ {'year': m.group(1), 'month': m.group(2), 'day': m.group(3),\
+ 'hour': hour, 'minute': m.group(6), 'second': m.group(7),\
+ 'zonediff': '+09:00'}
+ if _debug: sys.stderr.write('Nate date parsed as: %s\n' % w3dtfdate)
+ return _parse_date_w3dtf(w3dtfdate)
+registerDateHandler(_parse_date_nate)
+
+_mssql_date_re = \
+ re.compile('(\d{4})-(\d{2})-(\d{2})\s+(\d{2}):(\d{2}):(\d{2})(\.\d+)?')
+def _parse_date_mssql(dateString):
+ '''Parse a string according to the MS SQL date format'''
+ m = _mssql_date_re.match(dateString)
+ if not m: return
+ w3dtfdate = '%(year)s-%(month)s-%(day)sT%(hour)s:%(minute)s:%(second)s%(zonediff)s' % \
+ {'year': m.group(1), 'month': m.group(2), 'day': m.group(3),\
+ 'hour': m.group(4), 'minute': m.group(5), 'second': m.group(6),\
+ 'zonediff': '+09:00'}
+ if _debug: sys.stderr.write('MS SQL date parsed as: %s\n' % w3dtfdate)
+ return _parse_date_w3dtf(w3dtfdate)
+registerDateHandler(_parse_date_mssql)
+
+# Unicode strings for Greek date strings
+_greek_months = \
+ { \
+ u'\u0399\u03b1\u03bd': u'Jan', # c9e1ed in iso-8859-7
+ u'\u03a6\u03b5\u03b2': u'Feb', # d6e5e2 in iso-8859-7
+ u'\u039c\u03ac\u03ce': u'Mar', # ccdcfe in iso-8859-7
+ u'\u039c\u03b1\u03ce': u'Mar', # cce1fe in iso-8859-7
+ u'\u0391\u03c0\u03c1': u'Apr', # c1f0f1 in iso-8859-7
+ u'\u039c\u03ac\u03b9': u'May', # ccdce9 in iso-8859-7
+ u'\u039c\u03b1\u03ca': u'May', # cce1fa in iso-8859-7
+ u'\u039c\u03b1\u03b9': u'May', # cce1e9 in iso-8859-7
+ u'\u0399\u03bf\u03cd\u03bd': u'Jun', # c9effded in iso-8859-7
+ u'\u0399\u03bf\u03bd': u'Jun', # c9efed in iso-8859-7
+ u'\u0399\u03bf\u03cd\u03bb': u'Jul', # c9effdeb in iso-8859-7
+ u'\u0399\u03bf\u03bb': u'Jul', # c9f9eb in iso-8859-7
+ u'\u0391\u03cd\u03b3': u'Aug', # c1fde3 in iso-8859-7
+ u'\u0391\u03c5\u03b3': u'Aug', # c1f5e3 in iso-8859-7
+ u'\u03a3\u03b5\u03c0': u'Sep', # d3e5f0 in iso-8859-7
+ u'\u039f\u03ba\u03c4': u'Oct', # cfeaf4 in iso-8859-7
+ u'\u039d\u03bf\u03ad': u'Nov', # cdefdd in iso-8859-7
+ u'\u039d\u03bf\u03b5': u'Nov', # cdefe5 in iso-8859-7
+ u'\u0394\u03b5\u03ba': u'Dec', # c4e5ea in iso-8859-7
+ }
+
+_greek_wdays = \
+ { \
+ u'\u039a\u03c5\u03c1': u'Sun', # caf5f1 in iso-8859-7
+ u'\u0394\u03b5\u03c5': u'Mon', # c4e5f5 in iso-8859-7
+ u'\u03a4\u03c1\u03b9': u'Tue', # d4f1e9 in iso-8859-7
+ u'\u03a4\u03b5\u03c4': u'Wed', # d4e5f4 in iso-8859-7
+ u'\u03a0\u03b5\u03bc': u'Thu', # d0e5ec in iso-8859-7
+ u'\u03a0\u03b1\u03c1': u'Fri', # d0e1f1 in iso-8859-7
+ u'\u03a3\u03b1\u03b2': u'Sat', # d3e1e2 in iso-8859-7
+ }
+
+_greek_date_format_re = \
+ re.compile(u'([^,]+),\s+(\d{2})\s+([^\s]+)\s+(\d{4})\s+(\d{2}):(\d{2}):(\d{2})\s+([^\s]+)')
+
+def _parse_date_greek(dateString):
+ '''Parse a string according to a Greek 8-bit date format.'''
+ m = _greek_date_format_re.match(dateString)
+ if not m: return
+ try:
+ wday = _greek_wdays[m.group(1)]
+ month = _greek_months[m.group(3)]
+ except:
+ return
+ rfc822date = '%(wday)s, %(day)s %(month)s %(year)s %(hour)s:%(minute)s:%(second)s %(zonediff)s' % \
+ {'wday': wday, 'day': m.group(2), 'month': month, 'year': m.group(4),\
+ 'hour': m.group(5), 'minute': m.group(6), 'second': m.group(7),\
+ 'zonediff': m.group(8)}
+ if _debug: sys.stderr.write('Greek date parsed as: %s\n' % rfc822date)
+ return _parse_date_rfc822(rfc822date)
+registerDateHandler(_parse_date_greek)
+
+# Unicode strings for Hungarian date strings
+_hungarian_months = \
+ { \
+ u'janu\u00e1r': u'01', # e1 in iso-8859-2
+ u'febru\u00e1ri': u'02', # e1 in iso-8859-2
+ u'm\u00e1rcius': u'03', # e1 in iso-8859-2
+ u'\u00e1prilis': u'04', # e1 in iso-8859-2
+ u'm\u00e1ujus': u'05', # e1 in iso-8859-2
+ u'j\u00fanius': u'06', # fa in iso-8859-2
+ u'j\u00falius': u'07', # fa in iso-8859-2
+ u'augusztus': u'08',
+ u'szeptember': u'09',
+ u'okt\u00f3ber': u'10', # f3 in iso-8859-2
+ u'november': u'11',
+ u'december': u'12',
+ }
+
+_hungarian_date_format_re = \
+ re.compile(u'(\d{4})-([^-]+)-(\d{,2})T(\d{,2}):(\d{2})((\+|-)(\d{,2}:\d{2}))')
+
+def _parse_date_hungarian(dateString):
+ '''Parse a string according to a Hungarian 8-bit date format.'''
+ m = _hungarian_date_format_re.match(dateString)
+ if not m: return
+ try:
+ month = _hungarian_months[m.group(2)]
+ day = m.group(3)
+ if len(day) == 1:
+ day = '0' + day
+ hour = m.group(4)
+ if len(hour) == 1:
+ hour = '0' + hour
+ except:
+ return
+ w3dtfdate = '%(year)s-%(month)s-%(day)sT%(hour)s:%(minute)s%(zonediff)s' % \
+ {'year': m.group(1), 'month': month, 'day': day,\
+ 'hour': hour, 'minute': m.group(5),\
+ 'zonediff': m.group(6)}
+ if _debug: sys.stderr.write('Hungarian date parsed as: %s\n' % w3dtfdate)
+ return _parse_date_w3dtf(w3dtfdate)
+registerDateHandler(_parse_date_hungarian)
+
+# W3DTF-style date parsing adapted from PyXML xml.utils.iso8601, written by
+# Drake and licensed under the Python license. Removed all range checking
+# for month, day, hour, minute, and second, since mktime will normalize
+# these later
+def _parse_date_w3dtf(dateString):
+ def __extract_date(m):
+ year = int(m.group('year'))
+ if year < 100:
+ year = 100 * int(time.gmtime()[0] / 100) + int(year)
+ if year < 1000:
+ return 0, 0, 0
+ julian = m.group('julian')
+ if julian:
+ julian = int(julian)
+ month = julian / 30 + 1
+ day = julian % 30 + 1
+ jday = None
+ while jday != julian:
+ t = time.mktime((year, month, day, 0, 0, 0, 0, 0, 0))
+ jday = time.gmtime(t)[-2]
+ diff = abs(jday - julian)
+ if jday > julian:
+ if diff < day:
+ day = day - diff
+ else:
+ month = month - 1
+ day = 31
+ elif jday < julian:
+ if day + diff < 28:
+ day = day + diff
+ else:
+ month = month + 1
+ return year, month, day
+ month = m.group('month')
+ day = 1
+ if month is None:
+ month = 1
+ else:
+ month = int(month)
+ day = m.group('day')
+ if day:
+ day = int(day)
+ else:
+ day = 1
+ return year, month, day
+
+ def __extract_time(m):
+ if not m:
+ return 0, 0, 0
+ hours = m.group('hours')
+ if not hours:
+ return 0, 0, 0
+ hours = int(hours)
+ minutes = int(m.group('minutes'))
+ seconds = m.group('seconds')
+ if seconds:
+ seconds = int(seconds)
+ else:
+ seconds = 0
+ return hours, minutes, seconds
+
+ def __extract_tzd(m):
+ '''Return the Time Zone Designator as an offset in seconds from UTC.'''
+ if not m:
+ return 0
+ tzd = m.group('tzd')
+ if not tzd:
+ return 0
+ if tzd == 'Z':
+ return 0
+ hours = int(m.group('tzdhours'))
+ minutes = m.group('tzdminutes')
+ if minutes:
+ minutes = int(minutes)
+ else:
+ minutes = 0
+ offset = (hours*60 + minutes) * 60
+ if tzd[0] == '+':
+ return -offset
+ return offset
+
+ __date_re = ('(?P\d\d\d\d)'
+ '(?:(?P-|)'
+ '(?:(?P\d\d)(?:(?P=dsep)(?P\d\d))?'
+ '|(?P\d\d\d)))?')
+ __tzd_re = '(?P[-+](?P\d\d)(?::?(?P\d\d))|Z)'
+ __tzd_rx = re.compile(__tzd_re)
+ __time_re = ('(?P\d\d)(?P:|)(?P\d\d)'
+ '(?:(?P=tsep)(?P\d\d)(?:[.,]\d+)?)?'
+ + __tzd_re)
+ __datetime_re = '%s(?:T%s)?' % (__date_re, __time_re)
+ __datetime_rx = re.compile(__datetime_re)
+ m = __datetime_rx.match(dateString)
+ if (m is None) or (m.group() != dateString): return
+ gmt = __extract_date(m) + __extract_time(m) + (0, 0, 0)
+ if gmt[0] == 0: return
+ return time.gmtime(time.mktime(gmt) + __extract_tzd(m) - time.timezone)
+registerDateHandler(_parse_date_w3dtf)
+
+def _parse_date_rfc822(dateString):
+ '''Parse an RFC822, RFC1123, RFC2822, or asctime-style date'''
+ data = dateString.split()
+ if data[0][-1] in (',', '.') or data[0].lower() in rfc822._daynames:
+ del data[0]
+ if len(data) == 4:
+ s = data[3]
+ i = s.find('+')
+ if i > 0:
+ data[3:] = [s[:i], s[i+1:]]
+ else:
+ data.append('')
+ dateString = " ".join(data)
+ # Account for the Etc/GMT timezone by stripping 'Etc/'
+ elif len(data) == 5 and data[4].lower().startswith('etc/'):
+ data[4] = data[4][4:]
+ dateString = " ".join(data)
+ if len(data) < 5:
+ dateString += ' 00:00:00 GMT'
+ tm = rfc822.parsedate_tz(dateString)
+ if tm:
+ return time.gmtime(rfc822.mktime_tz(tm))
+# rfc822.py defines several time zones, but we define some extra ones.
+# 'ET' is equivalent to 'EST', etc.
+_additional_timezones = {'AT': -400, 'ET': -500, 'CT': -600, 'MT': -700, 'PT': -800}
+rfc822._timezones.update(_additional_timezones)
+registerDateHandler(_parse_date_rfc822)
+
+def _parse_date_perforce(aDateString):
+ """parse a date in yyyy/mm/dd hh:mm:ss TTT format"""
+ # Fri, 2006/09/15 08:19:53 EDT
+ _my_date_pattern = re.compile( \
+ r'(\w{,3}), (\d{,4})/(\d{,2})/(\d{2}) (\d{,2}):(\d{2}):(\d{2}) (\w{,3})')
+
+ dow, year, month, day, hour, minute, second, tz = \
+ _my_date_pattern.search(aDateString).groups()
+ months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec']
+ dateString = "%s, %s %s %s %s:%s:%s %s" % (dow, day, months[int(month) - 1], year, hour, minute, second, tz)
+ tm = rfc822.parsedate_tz(dateString)
+ if tm:
+ return time.gmtime(rfc822.mktime_tz(tm))
+registerDateHandler(_parse_date_perforce)
+
+def _parse_date(dateString):
+ '''Parses a variety of date formats into a 9-tuple in GMT'''
+ for handler in _date_handlers:
+ try:
+ date9tuple = handler(dateString)
+ if not date9tuple: continue
+ if len(date9tuple) != 9:
+ if _debug: sys.stderr.write('date handler function must return 9-tuple\n')
+ raise ValueError
+ map(int, date9tuple)
+ return date9tuple
+ except Exception, e:
+ if _debug: sys.stderr.write('%s raised %s\n' % (handler.__name__, repr(e)))
+ pass
+ return None
+
+def _getCharacterEncoding(http_headers, xml_data):
+ '''Get the character encoding of the XML document
+
+ http_headers is a dictionary
+ xml_data is a raw string (not Unicode)
+
+ This is so much trickier than it sounds, it's not even funny.
+ According to RFC 3023 ('XML Media Types'), if the HTTP Content-Type
+ is application/xml, application/*+xml,
+ application/xml-external-parsed-entity, or application/xml-dtd,
+ the encoding given in the charset parameter of the HTTP Content-Type
+ takes precedence over the encoding given in the XML prefix within the
+ document, and defaults to 'utf-8' if neither are specified. But, if
+ the HTTP Content-Type is text/xml, text/*+xml, or
+ text/xml-external-parsed-entity, the encoding given in the XML prefix
+ within the document is ALWAYS IGNORED and only the encoding given in
+ the charset parameter of the HTTP Content-Type header should be
+ respected, and it defaults to 'us-ascii' if not specified.
+
+ Furthermore, discussion on the atom-syntax mailing list with the
+ author of RFC 3023 leads me to the conclusion that any document
+ served with a Content-Type of text/* and no charset parameter
+ must be treated as us-ascii. (We now do this.) And also that it
+ must always be flagged as non-well-formed. (We now do this too.)
+
+ If Content-Type is unspecified (input was local file or non-HTTP source)
+ or unrecognized (server just got it totally wrong), then go by the
+ encoding given in the XML prefix of the document and default to
+ 'iso-8859-1' as per the HTTP specification (RFC 2616).
+
+ Then, assuming we didn't find a character encoding in the HTTP headers
+ (and the HTTP Content-type allowed us to look in the body), we need
+ to sniff the first few bytes of the XML data and try to determine
+ whether the encoding is ASCII-compatible. Section F of the XML
+ specification shows the way here:
+ http://www.w3.org/TR/REC-xml/#sec-guessing-no-ext-info
+
+ If the sniffed encoding is not ASCII-compatible, we need to make it
+ ASCII compatible so that we can sniff further into the XML declaration
+ to find the encoding attribute, which will tell us the true encoding.
+
+ Of course, none of this guarantees that we will be able to parse the
+ feed in the declared character encoding (assuming it was declared
+ correctly, which many are not). CJKCodecs and iconv_codec help a lot;
+ you should definitely install them if you can.
+ http://cjkpython.i18n.org/
+ '''
+
+ def _parseHTTPContentType(content_type):
+ '''takes HTTP Content-Type header and returns (content type, charset)
+
+ If no charset is specified, returns (content type, '')
+ If no content type is specified, returns ('', '')
+ Both return parameters are guaranteed to be lowercase strings
+ '''
+ content_type = content_type or ''
+ content_type, params = cgi.parse_header(content_type)
+ return content_type, params.get('charset', '').replace("'", '')
+
+ sniffed_xml_encoding = ''
+ xml_encoding = ''
+ true_encoding = ''
+ http_content_type, http_encoding = _parseHTTPContentType(http_headers.get('content-type', http_headers.get('Content-type')))
+ # Must sniff for non-ASCII-compatible character encodings before
+ # searching for XML declaration. This heuristic is defined in
+ # section F of the XML specification:
+ # http://www.w3.org/TR/REC-xml/#sec-guessing-no-ext-info
+ try:
+ if xml_data[:4] == _l2bytes([0x4c, 0x6f, 0xa7, 0x94]):
+ # EBCDIC
+ xml_data = _ebcdic_to_ascii(xml_data)
+ elif xml_data[:4] == _l2bytes([0x00, 0x3c, 0x00, 0x3f]):
+ # UTF-16BE
+ sniffed_xml_encoding = 'utf-16be'
+ xml_data = unicode(xml_data, 'utf-16be').encode('utf-8')
+ elif (len(xml_data) >= 4) and (xml_data[:2] == _l2bytes([0xfe, 0xff])) and (xml_data[2:4] != _l2bytes([0x00, 0x00])):
+ # UTF-16BE with BOM
+ sniffed_xml_encoding = 'utf-16be'
+ xml_data = unicode(xml_data[2:], 'utf-16be').encode('utf-8')
+ elif xml_data[:4] == _l2bytes([0x3c, 0x00, 0x3f, 0x00]):
+ # UTF-16LE
+ sniffed_xml_encoding = 'utf-16le'
+ xml_data = unicode(xml_data, 'utf-16le').encode('utf-8')
+ elif (len(xml_data) >= 4) and (xml_data[:2] == _l2bytes([0xff, 0xfe])) and (xml_data[2:4] != _l2bytes([0x00, 0x00])):
+ # UTF-16LE with BOM
+ sniffed_xml_encoding = 'utf-16le'
+ xml_data = unicode(xml_data[2:], 'utf-16le').encode('utf-8')
+ elif xml_data[:4] == _l2bytes([0x00, 0x00, 0x00, 0x3c]):
+ # UTF-32BE
+ sniffed_xml_encoding = 'utf-32be'
+ xml_data = unicode(xml_data, 'utf-32be').encode('utf-8')
+ elif xml_data[:4] == _l2bytes([0x3c, 0x00, 0x00, 0x00]):
+ # UTF-32LE
+ sniffed_xml_encoding = 'utf-32le'
+ xml_data = unicode(xml_data, 'utf-32le').encode('utf-8')
+ elif xml_data[:4] == _l2bytes([0x00, 0x00, 0xfe, 0xff]):
+ # UTF-32BE with BOM
+ sniffed_xml_encoding = 'utf-32be'
+ xml_data = unicode(xml_data[4:], 'utf-32be').encode('utf-8')
+ elif xml_data[:4] == _l2bytes([0xff, 0xfe, 0x00, 0x00]):
+ # UTF-32LE with BOM
+ sniffed_xml_encoding = 'utf-32le'
+ xml_data = unicode(xml_data[4:], 'utf-32le').encode('utf-8')
+ elif xml_data[:3] == _l2bytes([0xef, 0xbb, 0xbf]):
+ # UTF-8 with BOM
+ sniffed_xml_encoding = 'utf-8'
+ xml_data = unicode(xml_data[3:], 'utf-8').encode('utf-8')
+ else:
+ # ASCII-compatible
+ pass
+ xml_encoding_match = re.compile(_s2bytes('^<\?.*encoding=[\'"](.*?)[\'"].*\?>')).match(xml_data)
+ except:
+ xml_encoding_match = None
+ if xml_encoding_match:
+ xml_encoding = xml_encoding_match.groups()[0].decode('utf-8').lower()
+ if sniffed_xml_encoding and (xml_encoding in ('iso-10646-ucs-2', 'ucs-2', 'csunicode', 'iso-10646-ucs-4', 'ucs-4', 'csucs4', 'utf-16', 'utf-32', 'utf_16', 'utf_32', 'utf16', 'u16')):
+ xml_encoding = sniffed_xml_encoding
+ acceptable_content_type = 0
+ application_content_types = ('application/xml', 'application/xml-dtd', 'application/xml-external-parsed-entity')
+ text_content_types = ('text/xml', 'text/xml-external-parsed-entity')
+ if (http_content_type in application_content_types) or \
+ (http_content_type.startswith('application/') and http_content_type.endswith('+xml')):
+ acceptable_content_type = 1
+ true_encoding = http_encoding or xml_encoding or 'utf-8'
+ elif (http_content_type in text_content_types) or \
+ (http_content_type.startswith('text/')) and http_content_type.endswith('+xml'):
+ acceptable_content_type = 1
+ true_encoding = http_encoding or 'us-ascii'
+ elif http_content_type.startswith('text/'):
+ true_encoding = http_encoding or 'us-ascii'
+ elif http_headers and (not (http_headers.has_key('content-type') or http_headers.has_key('Content-type'))):
+ true_encoding = xml_encoding or 'iso-8859-1'
+ else:
+ true_encoding = xml_encoding or 'utf-8'
+ # some feeds claim to be gb2312 but are actually gb18030.
+ # apparently MSIE and Firefox both do the following switch:
+ if true_encoding.lower() == 'gb2312':
+ true_encoding = 'gb18030'
+ return true_encoding, http_encoding, xml_encoding, sniffed_xml_encoding, acceptable_content_type
+
+def _toUTF8(data, encoding):
+ '''Changes an XML data stream on the fly to specify a new encoding
+
+ data is a raw sequence of bytes (not Unicode) that is presumed to be in %encoding already
+ encoding is a string recognized by encodings.aliases
+ '''
+ if _debug: sys.stderr.write('entering _toUTF8, trying encoding %s\n' % encoding)
+ # strip Byte Order Mark (if present)
+ if (len(data) >= 4) and (data[:2] == _l2bytes([0xfe, 0xff])) and (data[2:4] != _l2bytes([0x00, 0x00])):
+ if _debug:
+ sys.stderr.write('stripping BOM\n')
+ if encoding != 'utf-16be':
+ sys.stderr.write('trying utf-16be instead\n')
+ encoding = 'utf-16be'
+ data = data[2:]
+ elif (len(data) >= 4) and (data[:2] == _l2bytes([0xff, 0xfe])) and (data[2:4] != _l2bytes([0x00, 0x00])):
+ if _debug:
+ sys.stderr.write('stripping BOM\n')
+ if encoding != 'utf-16le':
+ sys.stderr.write('trying utf-16le instead\n')
+ encoding = 'utf-16le'
+ data = data[2:]
+ elif data[:3] == _l2bytes([0xef, 0xbb, 0xbf]):
+ if _debug:
+ sys.stderr.write('stripping BOM\n')
+ if encoding != 'utf-8':
+ sys.stderr.write('trying utf-8 instead\n')
+ encoding = 'utf-8'
+ data = data[3:]
+ elif data[:4] == _l2bytes([0x00, 0x00, 0xfe, 0xff]):
+ if _debug:
+ sys.stderr.write('stripping BOM\n')
+ if encoding != 'utf-32be':
+ sys.stderr.write('trying utf-32be instead\n')
+ encoding = 'utf-32be'
+ data = data[4:]
+ elif data[:4] == _l2bytes([0xff, 0xfe, 0x00, 0x00]):
+ if _debug:
+ sys.stderr.write('stripping BOM\n')
+ if encoding != 'utf-32le':
+ sys.stderr.write('trying utf-32le instead\n')
+ encoding = 'utf-32le'
+ data = data[4:]
+ newdata = unicode(data, encoding)
+ if _debug: sys.stderr.write('successfully converted %s data to unicode\n' % encoding)
+ declmatch = re.compile('^<\?xml[^>]*?>')
+ newdecl = ''''''
+ if declmatch.search(newdata):
+ newdata = declmatch.sub(newdecl, newdata)
+ else:
+ newdata = newdecl + u'\n' + newdata
+ return newdata.encode('utf-8')
+
+def _stripDoctype(data):
+ '''Strips DOCTYPE from XML document, returns (rss_version, stripped_data)
+
+ rss_version may be 'rss091n' or None
+ stripped_data is the same XML document, minus the DOCTYPE
+ '''
+ start = re.search(_s2bytes('<\w'), data)
+ start = start and start.start() or -1
+ head,data = data[:start+1], data[start+1:]
+
+ entity_pattern = re.compile(_s2bytes(r'^\s*]*?)>'), re.MULTILINE)
+ entity_results=entity_pattern.findall(head)
+ head = entity_pattern.sub(_s2bytes(''), head)
+ doctype_pattern = re.compile(_s2bytes(r'^\s*]*?)>'), re.MULTILINE)
+ doctype_results = doctype_pattern.findall(head)
+ doctype = doctype_results and doctype_results[0] or _s2bytes('')
+ if doctype.lower().count(_s2bytes('netscape')):
+ version = 'rss091n'
+ else:
+ version = None
+
+ # only allow in 'safe' inline entity definitions
+ replacement=_s2bytes('')
+ if len(doctype_results)==1 and entity_results:
+ safe_pattern=re.compile(_s2bytes('\s+(\w+)\s+"(&#\w+;|[^&"]*)"'))
+ safe_entities=filter(lambda e: safe_pattern.match(e),entity_results)
+ if safe_entities:
+ replacement=_s2bytes('\n \n]>')
+ data = doctype_pattern.sub(replacement, head) + data
+
+ return version, data, dict(replacement and [(k.decode('utf-8'), v.decode('utf-8')) for k, v in safe_pattern.findall(replacement)])
+
+def parse(url_file_stream_or_string, etag=None, modified=None, agent=None, referrer=None, handlers=[], request_headers={}, response_headers={}):
+ '''Parse a feed from a URL, file, stream, or string.
+
+ request_headers, if given, is a dict from http header name to value to add
+ to the request; this overrides internally generated values.
+ '''
+ result = FeedParserDict()
+ result['feed'] = FeedParserDict()
+ result['entries'] = []
+ if _XML_AVAILABLE:
+ result['bozo'] = 0
+ if not isinstance(handlers, list):
+ handlers = [handlers]
+ try:
+ f = _open_resource(url_file_stream_or_string, etag, modified, agent, referrer, handlers, request_headers)
+ data = f.read()
+ except Exception, e:
+ result['bozo'] = 1
+ result['bozo_exception'] = e
+ data = None
+ f = None
+
+ if hasattr(f, 'headers'):
+ result['headers'] = dict(f.headers)
+ # overwrite existing headers using response_headers
+ if 'headers' in result:
+ result['headers'].update(response_headers)
+ elif response_headers:
+ result['headers'] = copy.deepcopy(response_headers)
+
+ # if feed is gzip-compressed, decompress it
+ if f and data and 'headers' in result:
+ if gzip and result['headers'].get('content-encoding') == 'gzip':
+ try:
+ data = gzip.GzipFile(fileobj=_StringIO(data)).read()
+ except Exception, e:
+ # Some feeds claim to be gzipped but they're not, so
+ # we get garbage. Ideally, we should re-request the
+ # feed without the 'Accept-encoding: gzip' header,
+ # but we don't.
+ result['bozo'] = 1
+ result['bozo_exception'] = e
+ data = ''
+ elif zlib and result['headers'].get('content-encoding') == 'deflate':
+ try:
+ data = zlib.decompress(data, -zlib.MAX_WBITS)
+ except Exception, e:
+ result['bozo'] = 1
+ result['bozo_exception'] = e
+ data = ''
+
+ # save HTTP headers
+ if 'headers' in result:
+ if 'etag' in result['headers'] or 'ETag' in result['headers']:
+ etag = result['headers'].get('etag', result['headers'].get('ETag'))
+ if etag:
+ result['etag'] = etag
+ if 'last-modified' in result['headers'] or 'Last-Modified' in result['headers']:
+ modified = result['headers'].get('last-modified', result['headers'].get('Last-Modified'))
+ if modified:
+ result['modified'] = _parse_date(modified)
+ if hasattr(f, 'url'):
+ result['href'] = f.url
+ result['status'] = 200
+ if hasattr(f, 'status'):
+ result['status'] = f.status
+ if hasattr(f, 'close'):
+ f.close()
+
+ # there are four encodings to keep track of:
+ # - http_encoding is the encoding declared in the Content-Type HTTP header
+ # - xml_encoding is the encoding declared in the }, L{Release }, or
+ L{Track }
+
+ 2. L{webservice}: An interface to the MusicBrainz XML web service.
+
+ 3. L{wsxml}: A parser for the web service XML format (MMD).
+
+ 4. L{disc}: Functions for creating and submitting DiscIDs.
+
+ 5. L{utils}: Utilities for working with URIs and other commonly needed tools.
+
+@author: Matthias Friedrich
+"""
+__revision__ = '$Id: __init__.py 12974 2011-05-01 08:43:54Z luks $'
+__version__ = '0.7.3'
+
+# EOF
diff --git a/lib/musicbrainz2/data/__init__.py b/lib/musicbrainz2/data/__init__.py
new file mode 100644
index 00000000..3067fabc
--- /dev/null
+++ b/lib/musicbrainz2/data/__init__.py
@@ -0,0 +1,10 @@
+"""Support data for the musicbrainz2 package.
+
+This package is I{not} part of the public API, it has been added to work
+around shortcomings in python and may thus be removed at any time.
+
+Please use the L{musicbrainz2.utils} module instead.
+"""
+__revision__ = '$Id: __init__.py 7386 2006-04-30 11:12:55Z matt $'
+
+# EOF
diff --git a/lib/musicbrainz2/data/countrynames.py b/lib/musicbrainz2/data/countrynames.py
new file mode 100644
index 00000000..7c4ab023
--- /dev/null
+++ b/lib/musicbrainz2/data/countrynames.py
@@ -0,0 +1,253 @@
+# -*- coding: utf-8 -*-
+
+__revision__ = '$Id: countrynames.py 7386 2006-04-30 11:12:55Z matt $'
+
+countryNames = {
+ u'BD': u'Bangladesh',
+ u'BE': u'Belgium',
+ u'BF': u'Burkina Faso',
+ u'BG': u'Bulgaria',
+ u'BB': u'Barbados',
+ u'WF': u'Wallis and Futuna Islands',
+ u'BM': u'Bermuda',
+ u'BN': u'Brunei Darussalam',
+ u'BO': u'Bolivia',
+ u'BH': u'Bahrain',
+ u'BI': u'Burundi',
+ u'BJ': u'Benin',
+ u'BT': u'Bhutan',
+ u'JM': u'Jamaica',
+ u'BV': u'Bouvet Island',
+ u'BW': u'Botswana',
+ u'WS': u'Samoa',
+ u'BR': u'Brazil',
+ u'BS': u'Bahamas',
+ u'BY': u'Belarus',
+ u'BZ': u'Belize',
+ u'RU': u'Russian Federation',
+ u'RW': u'Rwanda',
+ u'RE': u'Reunion',
+ u'TM': u'Turkmenistan',
+ u'TJ': u'Tajikistan',
+ u'RO': u'Romania',
+ u'TK': u'Tokelau',
+ u'GW': u'Guinea-Bissau',
+ u'GU': u'Guam',
+ u'GT': u'Guatemala',
+ u'GR': u'Greece',
+ u'GQ': u'Equatorial Guinea',
+ u'GP': u'Guadeloupe',
+ u'JP': u'Japan',
+ u'GY': u'Guyana',
+ u'GF': u'French Guiana',
+ u'GE': u'Georgia',
+ u'GD': u'Grenada',
+ u'GB': u'United Kingdom',
+ u'GA': u'Gabon',
+ u'SV': u'El Salvador',
+ u'GN': u'Guinea',
+ u'GM': u'Gambia',
+ u'GL': u'Greenland',
+ u'GI': u'Gibraltar',
+ u'GH': u'Ghana',
+ u'OM': u'Oman',
+ u'TN': u'Tunisia',
+ u'JO': u'Jordan',
+ u'HT': u'Haiti',
+ u'HU': u'Hungary',
+ u'HK': u'Hong Kong',
+ u'HN': u'Honduras',
+ u'HM': u'Heard and Mc Donald Islands',
+ u'VE': u'Venezuela',
+ u'PR': u'Puerto Rico',
+ u'PW': u'Palau',
+ u'PT': u'Portugal',
+ u'SJ': u'Svalbard and Jan Mayen Islands',
+ u'PY': u'Paraguay',
+ u'IQ': u'Iraq',
+ u'PA': u'Panama',
+ u'PF': u'French Polynesia',
+ u'PG': u'Papua New Guinea',
+ u'PE': u'Peru',
+ u'PK': u'Pakistan',
+ u'PH': u'Philippines',
+ u'PN': u'Pitcairn',
+ u'PL': u'Poland',
+ u'PM': u'St. Pierre and Miquelon',
+ u'ZM': u'Zambia',
+ u'EH': u'Western Sahara',
+ u'EE': u'Estonia',
+ u'EG': u'Egypt',
+ u'ZA': u'South Africa',
+ u'EC': u'Ecuador',
+ u'IT': u'Italy',
+ u'VN': u'Viet Nam',
+ u'SB': u'Solomon Islands',
+ u'ET': u'Ethiopia',
+ u'SO': u'Somalia',
+ u'ZW': u'Zimbabwe',
+ u'SA': u'Saudi Arabia',
+ u'ES': u'Spain',
+ u'ER': u'Eritrea',
+ u'MD': u'Moldova, Republic of',
+ u'MG': u'Madagascar',
+ u'MA': u'Morocco',
+ u'MC': u'Monaco',
+ u'UZ': u'Uzbekistan',
+ u'MM': u'Myanmar',
+ u'ML': u'Mali',
+ u'MO': u'Macau',
+ u'MN': u'Mongolia',
+ u'MH': u'Marshall Islands',
+ u'MK': u'Macedonia, The Former Yugoslav Republic of',
+ u'MU': u'Mauritius',
+ u'MT': u'Malta',
+ u'MW': u'Malawi',
+ u'MV': u'Maldives',
+ u'MQ': u'Martinique',
+ u'MP': u'Northern Mariana Islands',
+ u'MS': u'Montserrat',
+ u'MR': u'Mauritania',
+ u'UG': u'Uganda',
+ u'MY': u'Malaysia',
+ u'MX': u'Mexico',
+ u'IL': u'Israel',
+ u'FR': u'France',
+ u'IO': u'British Indian Ocean Territory',
+ u'SH': u'St. Helena',
+ u'FI': u'Finland',
+ u'FJ': u'Fiji',
+ u'FK': u'Falkland Islands (Malvinas)',
+ u'FM': u'Micronesia, Federated States of',
+ u'FO': u'Faroe Islands',
+ u'NI': u'Nicaragua',
+ u'NL': u'Netherlands',
+ u'NO': u'Norway',
+ u'NA': u'Namibia',
+ u'VU': u'Vanuatu',
+ u'NC': u'New Caledonia',
+ u'NE': u'Niger',
+ u'NF': u'Norfolk Island',
+ u'NG': u'Nigeria',
+ u'NZ': u'New Zealand',
+ u'ZR': u'Zaire',
+ u'NP': u'Nepal',
+ u'NR': u'Nauru',
+ u'NU': u'Niue',
+ u'CK': u'Cook Islands',
+ u'CI': u'Cote d\'Ivoire',
+ u'CH': u'Switzerland',
+ u'CO': u'Colombia',
+ u'CN': u'China',
+ u'CM': u'Cameroon',
+ u'CL': u'Chile',
+ u'CC': u'Cocos (Keeling) Islands',
+ u'CA': u'Canada',
+ u'CG': u'Congo',
+ u'CF': u'Central African Republic',
+ u'CZ': u'Czech Republic',
+ u'CY': u'Cyprus',
+ u'CX': u'Christmas Island',
+ u'CR': u'Costa Rica',
+ u'CV': u'Cape Verde',
+ u'CU': u'Cuba',
+ u'SZ': u'Swaziland',
+ u'SY': u'Syrian Arab Republic',
+ u'KG': u'Kyrgyzstan',
+ u'KE': u'Kenya',
+ u'SR': u'Suriname',
+ u'KI': u'Kiribati',
+ u'KH': u'Cambodia',
+ u'KN': u'Saint Kitts and Nevis',
+ u'KM': u'Comoros',
+ u'ST': u'Sao Tome and Principe',
+ u'SI': u'Slovenia',
+ u'KW': u'Kuwait',
+ u'SN': u'Senegal',
+ u'SM': u'San Marino',
+ u'SL': u'Sierra Leone',
+ u'SC': u'Seychelles',
+ u'KZ': u'Kazakhstan',
+ u'KY': u'Cayman Islands',
+ u'SG': u'Singapore',
+ u'SE': u'Sweden',
+ u'SD': u'Sudan',
+ u'DO': u'Dominican Republic',
+ u'DM': u'Dominica',
+ u'DJ': u'Djibouti',
+ u'DK': u'Denmark',
+ u'VG': u'Virgin Islands (British)',
+ u'DE': u'Germany',
+ u'YE': u'Yemen',
+ u'DZ': u'Algeria',
+ u'US': u'United States',
+ u'UY': u'Uruguay',
+ u'YT': u'Mayotte',
+ u'UM': u'United States Minor Outlying Islands',
+ u'LB': u'Lebanon',
+ u'LC': u'Saint Lucia',
+ u'LA': u'Lao People\'s Democratic Republic',
+ u'TV': u'Tuvalu',
+ u'TW': u'Taiwan',
+ u'TT': u'Trinidad and Tobago',
+ u'TR': u'Turkey',
+ u'LK': u'Sri Lanka',
+ u'LI': u'Liechtenstein',
+ u'LV': u'Latvia',
+ u'TO': u'Tonga',
+ u'LT': u'Lithuania',
+ u'LU': u'Luxembourg',
+ u'LR': u'Liberia',
+ u'LS': u'Lesotho',
+ u'TH': u'Thailand',
+ u'TF': u'French Southern Territories',
+ u'TG': u'Togo',
+ u'TD': u'Chad',
+ u'TC': u'Turks and Caicos Islands',
+ u'LY': u'Libyan Arab Jamahiriya',
+ u'VA': u'Vatican City State (Holy See)',
+ u'VC': u'Saint Vincent and The Grenadines',
+ u'AE': u'United Arab Emirates',
+ u'AD': u'Andorra',
+ u'AG': u'Antigua and Barbuda',
+ u'AF': u'Afghanistan',
+ u'AI': u'Anguilla',
+ u'VI': u'Virgin Islands (U.S.)',
+ u'IS': u'Iceland',
+ u'IR': u'Iran (Islamic Republic of)',
+ u'AM': u'Armenia',
+ u'AL': u'Albania',
+ u'AO': u'Angola',
+ u'AN': u'Netherlands Antilles',
+ u'AQ': u'Antarctica',
+ u'AS': u'American Samoa',
+ u'AR': u'Argentina',
+ u'AU': u'Australia',
+ u'AT': u'Austria',
+ u'AW': u'Aruba',
+ u'IN': u'India',
+ u'TZ': u'Tanzania, United Republic of',
+ u'AZ': u'Azerbaijan',
+ u'IE': u'Ireland',
+ u'ID': u'Indonesia',
+ u'UA': u'Ukraine',
+ u'QA': u'Qatar',
+ u'MZ': u'Mozambique',
+ u'BA': u'Bosnia and Herzegovina',
+ u'CD': u'Congo, The Democratic Republic of the',
+ u'CS': u'Serbia and Montenegro',
+ u'HR': u'Croatia',
+ u'KP': u'Korea (North), Democratic People\'s Republic of',
+ u'KR': u'Korea (South), Republic of',
+ u'SK': u'Slovakia',
+ u'SU': u'Soviet Union (historical, 1922-1991)',
+ u'TL': u'East Timor',
+ u'XC': u'Czechoslovakia (historical, 1918-1992)',
+ u'XE': u'Europe',
+ u'XG': u'East Germany (historical, 1949-1990)',
+ u'XU': u'[Unknown Country]',
+ u'XW': u'[Worldwide]',
+ u'YU': u'Yugoslavia (historical, 1918-1992)',
+}
+
+# EOF
diff --git a/lib/musicbrainz2/data/languagenames.py b/lib/musicbrainz2/data/languagenames.py
new file mode 100644
index 00000000..7f4252dc
--- /dev/null
+++ b/lib/musicbrainz2/data/languagenames.py
@@ -0,0 +1,400 @@
+# -*- coding: utf-8 -*-
+
+__revision__ = '$Id: languagenames.py 8725 2006-12-17 22:39:07Z luks $'
+
+languageNames = {
+ u'ART': u'Artificial (Other)',
+ u'ROH': u'Raeto-Romance',
+ u'SCO': u'Scots',
+ u'SCN': u'Sicilian',
+ u'ROM': u'Romany',
+ u'RON': u'Romanian',
+ u'OSS': u'Ossetian; Ossetic',
+ u'ALE': u'Aleut',
+ u'MNI': u'Manipuri',
+ u'NWC': u'Classical Newari; Old Newari; Classical Nepal Bhasa',
+ u'OSA': u'Osage',
+ u'MNC': u'Manchu',
+ u'MWR': u'Marwari',
+ u'VEN': u'Venda',
+ u'MWL': u'Mirandese',
+ u'FAS': u'Persian',
+ u'FAT': u'Fanti',
+ u'FAN': u'Fang',
+ u'FAO': u'Faroese',
+ u'DIN': u'Dinka',
+ u'HYE': u'Armenian',
+ u'DSB': u'Lower Sorbian',
+ u'CAR': u'Carib',
+ u'DIV': u'Divehi',
+ u'TEL': u'Telugu',
+ u'TEM': u'Timne',
+ u'NBL': u'Ndebele, South; South Ndebele',
+ u'TER': u'Tereno',
+ u'TET': u'Tetum',
+ u'SUN': u'Sundanese',
+ u'KUT': u'Kutenai',
+ u'SUK': u'Sukuma',
+ u'KUR': u'Kurdish',
+ u'KUM': u'Kumyk',
+ u'SUS': u'Susu',
+ u'NEW': u'Newari; Nepal Bhasa',
+ u'KUA': u'Kuanyama; Kwanyama',
+ u'MEN': u'Mende',
+ u'LEZ': u'Lezghian',
+ u'GLA': u'Gaelic; Scottish Gaelic',
+ u'BOS': u'Bosnian',
+ u'GLE': u'Irish',
+ u'EKA': u'Ekajuk',
+ u'GLG': u'Gallegan',
+ u'AKA': u'Akan',
+ u'BOD': u'Tibetan',
+ u'GLV': u'Manx',
+ u'JRB': u'Judeo-Arabic',
+ u'VIE': u'Vietnamese',
+ u'IPK': u'Inupiaq',
+ u'UZB': u'Uzbek',
+ u'BRE': u'Breton',
+ u'BRA': u'Braj',
+ u'AYM': u'Aymara',
+ u'CHA': u'Chamorro',
+ u'CHB': u'Chibcha',
+ u'CHE': u'Chechen',
+ u'CHG': u'Chagatai',
+ u'CHK': u'Chuukese',
+ u'CHM': u'Mari',
+ u'CHN': u'Chinook jargon',
+ u'CHO': u'Choctaw',
+ u'CHP': u'Chipewyan',
+ u'CHR': u'Cherokee',
+ u'CHU': u'Church Slavic; Old Slavonic; Church Slavonic; Old Bulgarian; Old Church Slavonic',
+ u'CHV': u'Chuvash',
+ u'CHY': u'Cheyenne',
+ u'MSA': u'Malay',
+ u'III': u'Sichuan Yi',
+ u'ACE': u'Achinese',
+ u'IBO': u'Igbo',
+ u'IBA': u'Iban',
+ u'XHO': u'Xhosa',
+ u'DEU': u'German',
+ u'CAT': u'Catalan; Valencian',
+ u'DEL': u'Delaware',
+ u'DEN': u'Slave (Athapascan)',
+ u'CAD': u'Caddo',
+ u'TAT': u'Tatar',
+ u'RAJ': u'Rajasthani',
+ u'SPA': u'Spanish; Castilian',
+ u'TAM': u'Tamil',
+ u'TAH': u'Tahitian',
+ u'AFH': u'Afrihili',
+ u'ENG': u'English',
+ u'CSB': u'Kashubian',
+ u'NYN': u'Nyankole',
+ u'NYO': u'Nyoro',
+ u'SID': u'Sidamo',
+ u'NYA': u'Chichewa; Chewa; Nyanja',
+ u'SIN': u'Sinhala; Sinhalese',
+ u'AFR': u'Afrikaans',
+ u'LAM': u'Lamba',
+ u'SND': u'Sindhi',
+ u'MAR': u'Marathi',
+ u'LAH': u'Lahnda',
+ u'NYM': u'Nyamwezi',
+ u'SNA': u'Shona',
+ u'LAD': u'Ladino',
+ u'SNK': u'Soninke',
+ u'MAD': u'Madurese',
+ u'MAG': u'Magahi',
+ u'MAI': u'Maithili',
+ u'MAH': u'Marshallese',
+ u'LAV': u'Latvian',
+ u'MAL': u'Malayalam',
+ u'MAN': u'Mandingo',
+ u'ZND': u'Zande',
+ u'ZEN': u'Zenaga',
+ u'KBD': u'Kabardian',
+ u'ITA': u'Italian',
+ u'VAI': u'Vai',
+ u'TSN': u'Tswana',
+ u'TSO': u'Tsonga',
+ u'TSI': u'Tsimshian',
+ u'BYN': u'Blin; Bilin',
+ u'FIJ': u'Fijian',
+ u'FIN': u'Finnish',
+ u'EUS': u'Basque',
+ u'CEB': u'Cebuano',
+ u'DAN': u'Danish',
+ u'NOG': u'Nogai',
+ u'NOB': u'Norwegian Bokmål; Bokmål, Norwegian',
+ u'DAK': u'Dakota',
+ u'CES': u'Czech',
+ u'DAR': u'Dargwa',
+ u'DAY': u'Dayak',
+ u'NOR': u'Norwegian',
+ u'KPE': u'Kpelle',
+ u'GUJ': u'Gujarati',
+ u'MDF': u'Moksha',
+ u'MAS': u'Masai',
+ u'LAO': u'Lao',
+ u'MDR': u'Mandar',
+ u'GON': u'Gondi',
+ u'SMS': u'Skolt Sami',
+ u'SMO': u'Samoan',
+ u'SMN': u'Inari Sami',
+ u'SMJ': u'Lule Sami',
+ u'GOT': u'Gothic',
+ u'SME': u'Northern Sami',
+ u'BLA': u'Siksika',
+ u'SMA': u'Southern Sami',
+ u'GOR': u'Gorontalo',
+ u'AST': u'Asturian; Bable',
+ u'ORM': u'Oromo',
+ u'QUE': u'Quechua',
+ u'ORI': u'Oriya',
+ u'CRH': u'Crimean Tatar; Crimean Turkish',
+ u'ASM': u'Assamese',
+ u'PUS': u'Pushto',
+ u'DGR': u'Dogrib',
+ u'LTZ': u'Luxembourgish; Letzeburgesch',
+ u'NDO': u'Ndonga',
+ u'GEZ': u'Geez',
+ u'ISL': u'Icelandic',
+ u'LAT': u'Latin',
+ u'MAK': u'Makasar',
+ u'ZAP': u'Zapotec',
+ u'YID': u'Yiddish',
+ u'KOK': u'Konkani',
+ u'KOM': u'Komi',
+ u'KON': u'Kongo',
+ u'UKR': u'Ukrainian',
+ u'TON': u'Tonga (Tonga Islands)',
+ u'KOS': u'Kosraean',
+ u'KOR': u'Korean',
+ u'TOG': u'Tonga (Nyasa)',
+ u'HUN': u'Hungarian',
+ u'HUP': u'Hupa',
+ u'CYM': u'Welsh',
+ u'UDM': u'Udmurt',
+ u'BEJ': u'Beja',
+ u'BEN': u'Bengali',
+ u'BEL': u'Belarusian',
+ u'BEM': u'Bemba',
+ u'AAR': u'Afar',
+ u'NZI': u'Nzima',
+ u'SAH': u'Yakut',
+ u'SAN': u'Sanskrit',
+ u'SAM': u'Samaritan Aramaic',
+ u'SAG': u'Sango',
+ u'SAD': u'Sandawe',
+ u'RAR': u'Rarotongan',
+ u'RAP': u'Rapanui',
+ u'SAS': u'Sasak',
+ u'SAT': u'Santali',
+ u'MIN': u'Minangkabau',
+ u'LIM': u'Limburgan; Limburger; Limburgish',
+ u'LIN': u'Lingala',
+ u'LIT': u'Lithuanian',
+ u'EFI': u'Efik',
+ u'BTK': u'Batak (Indonesia)',
+ u'KAC': u'Kachin',
+ u'KAB': u'Kabyle',
+ u'KAA': u'Kara-Kalpak',
+ u'KAN': u'Kannada',
+ u'KAM': u'Kamba',
+ u'KAL': u'Kalaallisut; Greenlandic',
+ u'KAS': u'Kashmiri',
+ u'KAR': u'Karen',
+ u'KAU': u'Kanuri',
+ u'KAT': u'Georgian',
+ u'KAZ': u'Kazakh',
+ u'TYV': u'Tuvinian',
+ u'AWA': u'Awadhi',
+ u'URD': u'Urdu',
+ u'DOI': u'Dogri',
+ u'TPI': u'Tok Pisin',
+ u'MRI': u'Maori',
+ u'ABK': u'Abkhazian',
+ u'TKL': u'Tokelau',
+ u'NLD': u'Dutch; Flemish',
+ u'OJI': u'Ojibwa',
+ u'OCI': u'Occitan (post 1500); Provençal',
+ u'WOL': u'Wolof',
+ u'JAV': u'Javanese',
+ u'HRV': u'Croatian',
+ u'DYU': u'Dyula',
+ u'SSW': u'Swati',
+ u'MUL': u'Multiple languages',
+ u'HIL': u'Hiligaynon',
+ u'HIM': u'Himachali',
+ u'HIN': u'Hindi',
+ u'BAS': u'Basa',
+ u'GBA': u'Gbaya',
+ u'WLN': u'Walloon',
+ u'BAD': u'Banda',
+ u'NEP': u'Nepali',
+ u'CRE': u'Cree',
+ u'BAN': u'Balinese',
+ u'BAL': u'Baluchi',
+ u'BAM': u'Bambara',
+ u'BAK': u'Bashkir',
+ u'SHN': u'Shan',
+ u'ARP': u'Arapaho',
+ u'ARW': u'Arawak',
+ u'ARA': u'Arabic',
+ u'ARC': u'Aramaic',
+ u'ARG': u'Aragonese',
+ u'SEL': u'Selkup',
+ u'ARN': u'Araucanian',
+ u'LUS': u'Lushai',
+ u'MUS': u'Creek',
+ u'LUA': u'Luba-Lulua',
+ u'LUB': u'Luba-Katanga',
+ u'LUG': u'Ganda',
+ u'LUI': u'Luiseno',
+ u'LUN': u'Lunda',
+ u'LUO': u'Luo (Kenya and Tanzania)',
+ u'IKU': u'Inuktitut',
+ u'TUR': u'Turkish',
+ u'TUK': u'Turkmen',
+ u'TUM': u'Tumbuka',
+ u'COP': u'Coptic',
+ u'COS': u'Corsican',
+ u'COR': u'Cornish',
+ u'ILO': u'Iloko',
+ u'GWI': u'Gwich´in',
+ u'TLI': u'Tlingit',
+ u'TLH': u'Klingon; tlhIngan-Hol',
+ u'POR': u'Portuguese',
+ u'PON': u'Pohnpeian',
+ u'POL': u'Polish',
+ u'TGK': u'Tajik',
+ u'TGL': u'Tagalog',
+ u'FRA': u'French',
+ u'BHO': u'Bhojpuri',
+ u'SWA': u'Swahili',
+ u'DUA': u'Duala',
+ u'SWE': u'Swedish',
+ u'YAP': u'Yapese',
+ u'TIV': u'Tiv',
+ u'YAO': u'Yao',
+ u'XAL': u'Kalmyk',
+ u'FRY': u'Frisian',
+ u'GAY': u'Gayo',
+ u'OTA': u'Turkish, Ottoman (1500-1928)',
+ u'HMN': u'Hmong',
+ u'HMO': u'Hiri Motu',
+ u'GAA': u'Ga',
+ u'FUR': u'Friulian',
+ u'MLG': u'Malagasy',
+ u'SLV': u'Slovenian',
+ u'FIL': u'Filipino; Pilipino',
+ u'MLT': u'Maltese',
+ u'SLK': u'Slovak',
+ u'FUL': u'Fulah',
+ u'JPN': u'Japanese',
+ u'VOL': u'Volapük',
+ u'VOT': u'Votic',
+ u'IND': u'Indonesian',
+ u'AVE': u'Avestan',
+ u'JPR': u'Judeo-Persian',
+ u'AVA': u'Avaric',
+ u'PAP': u'Papiamento',
+ u'EWO': u'Ewondo',
+ u'PAU': u'Palauan',
+ u'EWE': u'Ewe',
+ u'PAG': u'Pangasinan',
+ u'PAM': u'Pampanga',
+ u'PAN': u'Panjabi; Punjabi',
+ u'KIR': u'Kirghiz',
+ u'NIA': u'Nias',
+ u'KIK': u'Kikuyu; Gikuyu',
+ u'SYR': u'Syriac',
+ u'KIN': u'Kinyarwanda',
+ u'NIU': u'Niuean',
+ u'EPO': u'Esperanto',
+ u'JBO': u'Lojban',
+ u'MIC': u'Mi\'kmaq; Micmac',
+ u'THA': u'Thai',
+ u'HAI': u'Haida',
+ u'ELL': u'Greek, Modern (1453-)',
+ u'ADY': u'Adyghe; Adygei',
+ u'ELX': u'Elamite',
+ u'ADA': u'Adangme',
+ u'GRB': u'Grebo',
+ u'HAT': u'Haitian; Haitian Creole',
+ u'HAU': u'Hausa',
+ u'HAW': u'Hawaiian',
+ u'BIN': u'Bini',
+ u'AMH': u'Amharic',
+ u'BIK': u'Bikol',
+ u'BIH': u'Bihari',
+ u'MOS': u'Mossi',
+ u'MOH': u'Mohawk',
+ u'MON': u'Mongolian',
+ u'MOL': u'Moldavian',
+ u'BIS': u'Bislama',
+ u'TVL': u'Tuvalu',
+ u'IJO': u'Ijo',
+ u'EST': u'Estonian',
+ u'KMB': u'Kimbundu',
+ u'UMB': u'Umbundu',
+ u'TMH': u'Tamashek',
+ u'FON': u'Fon',
+ u'HSB': u'Upper Sorbian',
+ u'RUN': u'Rundi',
+ u'RUS': u'Russian',
+ u'PLI': u'Pali',
+ u'SRD': u'Sardinian',
+ u'ACH': u'Acoli',
+ u'NDE': u'Ndebele, North; North Ndebele',
+ u'DZO': u'Dzongkha',
+ u'KRU': u'Kurukh',
+ u'SRR': u'Serer',
+ u'IDO': u'Ido',
+ u'SRP': u'Serbian',
+ u'KRO': u'Kru',
+ u'KRC': u'Karachay-Balkar',
+ u'NDS': u'Low German; Low Saxon; German, Low; Saxon, Low',
+ u'ZUN': u'Zuni',
+ u'ZUL': u'Zulu',
+ u'TWI': u'Twi',
+ u'NSO': u'Northern Sotho, Pedi; Sepedi',
+ u'SOM': u'Somali',
+ u'SON': u'Songhai',
+ u'SOT': u'Sotho, Southern',
+ u'MKD': u'Macedonian',
+ u'HER': u'Herero',
+ u'LOL': u'Mongo',
+ u'HEB': u'Hebrew',
+ u'LOZ': u'Lozi',
+ u'GIL': u'Gilbertese',
+ u'WAS': u'Washo',
+ u'WAR': u'Waray',
+ u'BUL': u'Bulgarian',
+ u'WAL': u'Walamo',
+ u'BUA': u'Buriat',
+ u'BUG': u'Buginese',
+ u'AZE': u'Azerbaijani',
+ u'ZHA': u'Zhuang; Chuang',
+ u'ZHO': u'Chinese',
+ u'NNO': u'Norwegian Nynorsk; Nynorsk, Norwegian',
+ u'UIG': u'Uighur; Uyghur',
+ u'MYV': u'Erzya',
+ u'INH': u'Ingush',
+ u'KHM': u'Khmer',
+ u'MYA': u'Burmese',
+ u'KHA': u'Khasi',
+ u'INA': u'Interlingua (International Auxiliary Language Association)',
+ u'NAH': u'Nahuatl',
+ u'TIR': u'Tigrinya',
+ u'NAP': u'Neapolitan',
+ u'NAV': u'Navajo; Navaho',
+ u'NAU': u'Nauru',
+ u'GRN': u'Guarani',
+ u'TIG': u'Tigre',
+ u'YOR': u'Yoruba',
+ u'ILE': u'Interlingue',
+ u'SQI': u'Albanian',
+}
+
+# EOF
diff --git a/lib/musicbrainz2/data/releasetypenames.py b/lib/musicbrainz2/data/releasetypenames.py
new file mode 100644
index 00000000..f16ed19e
--- /dev/null
+++ b/lib/musicbrainz2/data/releasetypenames.py
@@ -0,0 +1,24 @@
+# -*- coding: utf-8 -*-
+
+__revision__ = '$Id: releasetypenames.py 8728 2006-12-17 23:42:30Z luks $'
+
+releaseTypeNames = {
+ u'http://musicbrainz.org/ns/mmd-1.0#None': u'None',
+ u'http://musicbrainz.org/ns/mmd-1.0#Album': u'Album',
+ u'http://musicbrainz.org/ns/mmd-1.0#Single': u'Single',
+ u'http://musicbrainz.org/ns/mmd-1.0#EP': u'EP',
+ u'http://musicbrainz.org/ns/mmd-1.0#Compilation': u'Compilation',
+ u'http://musicbrainz.org/ns/mmd-1.0#Soundtrack': u'Soundtrack',
+ u'http://musicbrainz.org/ns/mmd-1.0#Spokenword': u'Spokenword',
+ u'http://musicbrainz.org/ns/mmd-1.0#Interview': u'Interview',
+ u'http://musicbrainz.org/ns/mmd-1.0#Audiobook': u'Audiobook',
+ u'http://musicbrainz.org/ns/mmd-1.0#Live': u'Live',
+ u'http://musicbrainz.org/ns/mmd-1.0#Remix': u'Remix',
+ u'http://musicbrainz.org/ns/mmd-1.0#Other': u'Other',
+ u'http://musicbrainz.org/ns/mmd-1.0#Official': u'Official',
+ u'http://musicbrainz.org/ns/mmd-1.0#Promotion': u'Promotion',
+ u'http://musicbrainz.org/ns/mmd-1.0#Bootleg': u'Bootleg',
+ u'http://musicbrainz.org/ns/mmd-1.0#Pseudo-Release': u'Pseudo-Release',
+}
+
+# EOF
diff --git a/lib/musicbrainz2/data/scriptnames.py b/lib/musicbrainz2/data/scriptnames.py
new file mode 100644
index 00000000..30a55bd7
--- /dev/null
+++ b/lib/musicbrainz2/data/scriptnames.py
@@ -0,0 +1,59 @@
+# -*- coding: utf-8 -*-
+
+__revision__ = '$Id: scriptnames.py 7386 2006-04-30 11:12:55Z matt $'
+
+scriptNames = {
+ u'Yiii': u'Yi',
+ u'Telu': u'Telugu',
+ u'Taml': u'Tamil',
+ u'Guru': u'Gurmukhi',
+ u'Hebr': u'Hebrew',
+ u'Geor': u'Georgian (Mkhedruli)',
+ u'Ugar': u'Ugaritic',
+ u'Cyrl': u'Cyrillic',
+ u'Hrkt': u'Kanji & Kana',
+ u'Armn': u'Armenian',
+ u'Runr': u'Runic',
+ u'Khmr': u'Khmer',
+ u'Latn': u'Latin',
+ u'Hani': u'Han (Hanzi, Kanji, Hanja)',
+ u'Ital': u'Old Italic (Etruscan, Oscan, etc.)',
+ u'Hano': u'Hanunoo (Hanunóo)',
+ u'Ethi': u'Ethiopic (Ge\'ez)',
+ u'Gujr': u'Gujarati',
+ u'Hang': u'Hangul',
+ u'Arab': u'Arabic',
+ u'Thaa': u'Thaana',
+ u'Buhd': u'Buhid',
+ u'Sinh': u'Sinhala',
+ u'Orya': u'Oriya',
+ u'Hans': u'Han (Simplified variant)',
+ u'Thai': u'Thai',
+ u'Cprt': u'Cypriot',
+ u'Linb': u'Linear B',
+ u'Hant': u'Han (Traditional variant)',
+ u'Osma': u'Osmanya',
+ u'Mong': u'Mongolian',
+ u'Deva': u'Devanagari (Nagari)',
+ u'Laoo': u'Lao',
+ u'Tagb': u'Tagbanwa',
+ u'Hira': u'Hiragana',
+ u'Bopo': u'Bopomofo',
+ u'Goth': u'Gothic',
+ u'Tale': u'Tai Le',
+ u'Mymr': u'Myanmar (Burmese)',
+ u'Tglg': u'Tagalog',
+ u'Grek': u'Greek',
+ u'Mlym': u'Malayalam',
+ u'Cher': u'Cherokee',
+ u'Tibt': u'Tibetan',
+ u'Kana': u'Katakana',
+ u'Syrc': u'Syriac',
+ u'Cans': u'Unified Canadian Aboriginal Syllabics',
+ u'Beng': u'Bengali',
+ u'Limb': u'Limbu',
+ u'Ogam': u'Ogham',
+ u'Knda': u'Kannada',
+}
+
+# EOF
diff --git a/lib/musicbrainz2/disc.py b/lib/musicbrainz2/disc.py
new file mode 100644
index 00000000..871c6084
--- /dev/null
+++ b/lib/musicbrainz2/disc.py
@@ -0,0 +1,221 @@
+"""Utilities for working with Audio CDs.
+
+This module contains utilities for working with Audio CDs.
+
+The functions in this module need both a working ctypes package (already
+included in python-2.5) and an installed libdiscid. If you don't have
+libdiscid, it can't be loaded, or your platform isn't supported by either
+ctypes or this module, a C{NotImplementedError} is raised when using the
+L{readDisc()} function.
+
+@author: Matthias Friedrich
+"""
+__revision__ = '$Id: disc.py 11987 2009-08-22 11:57:51Z matt $'
+
+import sys
+import urllib
+import urlparse
+import ctypes
+import ctypes.util
+from lib.musicbrainz2.model import Disc
+
+__all__ = [ 'DiscError', 'readDisc', 'getSubmissionUrl' ]
+
+
+class DiscError(IOError):
+ """The Audio CD could not be read.
+
+ This may be simply because no disc was in the drive, the device name
+ was wrong or the disc can't be read. Reading errors can occur in case
+ of a damaged disc or a copy protection mechanism, for example.
+ """
+ pass
+
+
+def _openLibrary():
+ """Tries to open libdiscid.
+
+ @return: a C{ctypes.CDLL} object, representing the opened library
+
+ @raise NotImplementedError: if the library can't be opened
+ """
+ # This only works for ctypes >= 0.9.9.3. Any libdiscid is found,
+ # no matter how it's called on this platform.
+ try:
+ if hasattr(ctypes.cdll, 'find'):
+ libDiscId = ctypes.cdll.find('discid')
+ _setPrototypes(libDiscId)
+ return libDiscId
+ except OSError, e:
+ raise NotImplementedError('Error opening library: ' + str(e))
+
+ # Try to find the library using ctypes.util
+ libName = ctypes.util.find_library('discid')
+ if libName != None:
+ try:
+ libDiscId = ctypes.cdll.LoadLibrary(libName)
+ _setPrototypes(libDiscId)
+ return libDiscId
+ except OSError, e:
+ raise NotImplementedError('Error opening library: ' +
+ str(e))
+
+ # For compatibility with ctypes < 0.9.9.3 try to figure out the library
+ # name without the help of ctypes. We use cdll.LoadLibrary() below,
+ # which isn't available for ctypes == 0.9.9.3.
+ #
+ if sys.platform == 'linux2':
+ libName = 'libdiscid.so.0'
+ elif sys.platform == 'darwin':
+ libName = 'libdiscid.0.dylib'
+ elif sys.platform == 'win32':
+ libName = 'discid.dll'
+ else:
+ # This should at least work for Un*x-style operating systems
+ libName = 'libdiscid.so.0'
+
+ try:
+ libDiscId = ctypes.cdll.LoadLibrary(libName)
+ _setPrototypes(libDiscId)
+ return libDiscId
+ except OSError, e:
+ raise NotImplementedError('Error opening library: ' + str(e))
+
+ assert False # not reached
+
+
+def _setPrototypes(libDiscId):
+ ct = ctypes
+ libDiscId.discid_new.argtypes = ( )
+ libDiscId.discid_new.restype = ct.c_void_p
+
+ libDiscId.discid_free.argtypes = (ct.c_void_p, )
+
+ libDiscId.discid_read.argtypes = (ct.c_void_p, ct.c_char_p)
+
+ libDiscId.discid_get_error_msg.argtypes = (ct.c_void_p, )
+ libDiscId.discid_get_error_msg.restype = ct.c_char_p
+
+ libDiscId.discid_get_id.argtypes = (ct.c_void_p, )
+ libDiscId.discid_get_id.restype = ct.c_char_p
+
+ libDiscId.discid_get_first_track_num.argtypes = (ct.c_void_p, )
+ libDiscId.discid_get_first_track_num.restype = ct.c_int
+
+ libDiscId.discid_get_last_track_num.argtypes = (ct.c_void_p, )
+ libDiscId.discid_get_last_track_num.restype = ct.c_int
+
+ libDiscId.discid_get_sectors.argtypes = (ct.c_void_p, )
+ libDiscId.discid_get_sectors.restype = ct.c_int
+
+ libDiscId.discid_get_track_offset.argtypes = (ct.c_void_p, ct.c_int)
+ libDiscId.discid_get_track_offset.restype = ct.c_int
+
+ libDiscId.discid_get_track_length.argtypes = (ct.c_void_p, ct.c_int)
+ libDiscId.discid_get_track_length.restype = ct.c_int
+
+
+def getSubmissionUrl(disc, host='mm.musicbrainz.org', port=80):
+ """Returns a URL for adding a disc to the MusicBrainz database.
+
+ A fully initialized L{musicbrainz2.model.Disc} object is needed, as
+ returned by L{readDisc}. A disc object returned by the web service
+ doesn't provide the necessary information.
+
+ Note that the created URL is intended for interactive use and points
+ to the MusicBrainz disc submission wizard by default. This method
+ just returns a URL, no network connection is needed. The disc drive
+ isn't used.
+
+ @param disc: a fully initialized L{musicbrainz2.model.Disc} object
+ @param host: a string containing a host name
+ @param port: an integer containing a port number
+
+ @return: a string containing the submission URL
+
+ @see: L{readDisc}
+ """
+ assert isinstance(disc, Disc), 'musicbrainz2.model.Disc expected'
+ discid = disc.getId()
+ first = disc.getFirstTrackNum()
+ last = disc.getLastTrackNum()
+ sectors = disc.getSectors()
+ assert None not in (discid, first, last, sectors)
+
+ tracks = last - first + 1
+ toc = "%d %d %d " % (first, last, sectors)
+ toc = toc + ' '.join( map(lambda x: str(x[0]), disc.getTracks()) )
+
+ query = urllib.urlencode({ 'id': discid, 'toc': toc, 'tracks': tracks })
+
+ if port == 80:
+ netloc = host
+ else:
+ netloc = host + ':' + str(port)
+
+ url = ('http', netloc, '/bare/cdlookup.html', '', query, '')
+
+ return urlparse.urlunparse(url)
+
+
+def readDisc(deviceName=None):
+ """Reads an Audio CD in the disc drive.
+
+ This reads a CD's table of contents (TOC) and calculates the MusicBrainz
+ DiscID, which is a 28 character ASCII string. This DiscID can be used
+ to retrieve a list of matching releases from the web service (see
+ L{musicbrainz2.webservice.Query}).
+
+ Note that an Audio CD has to be in drive for this to work. The
+ C{deviceName} argument may be used to set the device. The default
+ depends on the operating system (on linux, it's C{'/dev/cdrom'}).
+ No network connection is needed for this function.
+
+ If the device doesn't exist or there's no valid Audio CD in the drive,
+ a L{DiscError} exception is raised.
+
+ @param deviceName: a string containing the CD drive's device name
+
+ @return: a L{musicbrainz2.model.Disc} object
+
+ @raise DiscError: if there was a problem reading the disc
+ @raise NotImplementedError: if DiscID generation isn't supported
+ """
+ libDiscId = _openLibrary()
+
+ handle = libDiscId.discid_new()
+ assert handle != 0, "libdiscid: discid_new() returned NULL"
+
+ # Access the CD drive. This also works if deviceName is None because
+ # ctypes passes a NULL pointer in this case.
+ #
+ res = libDiscId.discid_read(handle, deviceName)
+ if res == 0:
+ raise DiscError(libDiscId.discid_get_error_msg(handle))
+
+
+ # Now extract the data from the result.
+ #
+ disc = Disc()
+
+ disc.setId( libDiscId.discid_get_id(handle) )
+
+ firstTrackNum = libDiscId.discid_get_first_track_num(handle)
+ lastTrackNum = libDiscId.discid_get_last_track_num(handle)
+
+ disc.setSectors(libDiscId.discid_get_sectors(handle))
+
+ for i in range(firstTrackNum, lastTrackNum+1):
+ trackOffset = libDiscId.discid_get_track_offset(handle, i)
+ trackSectors = libDiscId.discid_get_track_length(handle, i)
+
+ disc.addTrack( (trackOffset, trackSectors) )
+
+ disc.setFirstTrackNum(firstTrackNum)
+ disc.setLastTrackNum(lastTrackNum)
+
+ libDiscId.discid_free(handle)
+
+ return disc
+
+# EOF
diff --git a/lib/musicbrainz2/model.py b/lib/musicbrainz2/model.py
new file mode 100644
index 00000000..fe8f05df
--- /dev/null
+++ b/lib/musicbrainz2/model.py
@@ -0,0 +1,2488 @@
+"""The MusicBrainz domain model.
+
+These classes are part of the MusicBrainz domain model. They may be used
+by other modules and don't contain any network or other I/O code. If you
+want to request data from the web service, please have a look at
+L{musicbrainz2.webservice}.
+
+The most important classes, usually acting as entry points, are
+L{Artist}, L{Release}, and L{Track}.
+
+@var VARIOUS_ARTISTS_ID: The ID of the special 'Various Artists' artist.
+
+@var NS_MMD_1: Default namespace prefix for all MusicBrainz metadata.
+@var NS_REL_1: Namespace prefix for relations.
+@var NS_EXT_1: Namespace prefix for MusicBrainz extensions.
+
+@see: L{musicbrainz2.webservice}
+
+@author: Matthias Friedrich
+"""
+try:
+ set
+except NameError:
+ from sets import Set as set
+
+__revision__ = '$Id: model.py 12829 2010-09-15 12:00:11Z luks $'
+
+__all__ = [
+ 'VARIOUS_ARTISTS_ID', 'NS_MMD_1', 'NS_REL_1', 'NS_EXT_1',
+ 'Entity', 'Artist', 'Release', 'Track', 'User', 'ReleaseGroup',
+ 'Relation', 'Disc', 'ReleaseEvent', 'Label', 'Tag', 'Rating',
+ 'AbstractAlias', 'ArtistAlias', 'LabelAlias',
+]
+
+
+VARIOUS_ARTISTS_ID = 'http://musicbrainz.org/artist/89ad4ac3-39f7-470e-963a-56509c546377'
+
+# Namespace URI prefixes
+#
+NS_MMD_1 = 'http://musicbrainz.org/ns/mmd-1.0#'
+NS_REL_1 = 'http://musicbrainz.org/ns/rel-1.0#'
+NS_EXT_1 = 'http://musicbrainz.org/ns/ext-1.0#'
+
+
+class Entity(object):
+ """A first-level MusicBrainz class.
+
+ All entities in MusicBrainz have unique IDs (which are absolute URIs)
+ as well as any number of L{relations } to other entities
+ and free text tags. This class is abstract and should not be
+ instantiated.
+
+ Relations are differentiated by their I{target type}, that means,
+ where they link to. MusicBrainz currently supports four target types
+ (artists, releases, tracks, and URLs) each identified using a URI.
+ To get all relations with a specific target type, you can use
+ L{getRelations} and pass one of the following constants as the
+ parameter:
+
+ - L{Relation.TO_ARTIST}
+ - L{Relation.TO_RELEASE}
+ - L{Relation.TO_TRACK}
+ - L{Relation.TO_URL}
+
+ @see: L{Relation}
+ """
+
+ def __init__(self, id_=None):
+ """Constructor.
+
+ This should only used by derived classes.
+
+ @param id_: a string containing an absolute URI
+ """
+ self._id = id_
+ self._relations = { }
+ self._tags = { }
+ self._rating = Rating()
+
+ def getId(self):
+ """Returns a MusicBrainz ID.
+
+ @return: a string containing a URI, or None
+ """
+ return self._id
+
+ def setId(self, value):
+ """Sets a MusicBrainz ID.
+
+ @param value: a string containing an absolute URI
+ """
+ self._id = value
+
+ id = property(getId, setId, doc='The MusicBrainz ID.')
+
+ def getRelations(self, targetType=None, relationType=None,
+ requiredAttributes=(), direction=None):
+ """Returns a list of relations.
+
+ If C{targetType} is given, only relations of that target
+ type are returned. For MusicBrainz, the following target
+ types are defined:
+ - L{Relation.TO_ARTIST}
+ - L{Relation.TO_RELEASE}
+ - L{Relation.TO_TRACK}
+ - L{Relation.TO_URL}
+
+ If C{targetType} is L{Relation.TO_ARTIST}, for example,
+ this method returns all relations between this Entity and
+ artists.
+
+ You may use the C{relationType} parameter to further restrict
+ the selection. If it is set, only relations with the given
+ relation type are returned. The C{requiredAttributes} sequence
+ lists attributes that have to be part of all returned relations.
+
+ If C{direction} is set, only relations with the given reading
+ direction are returned. You can use the L{Relation.DIR_FORWARD},
+ L{Relation.DIR_BACKWARD}, and L{Relation.DIR_NONE} constants
+ for this.
+
+ @param targetType: a string containing an absolute URI, or None
+ @param relationType: a string containing an absolute URI, or None
+ @param requiredAttributes: a sequence containing absolute URIs
+ @param direction: one of L{Relation}'s direction constants
+ @return: a list of L{Relation} objects
+
+ @see: L{Entity}
+ """
+ allRels = [ ]
+ if targetType is not None:
+ allRels = self._relations.setdefault(targetType, [ ])
+ else:
+ for (k, relList) in self._relations.items():
+ for rel in relList:
+ allRels.append(rel)
+
+ # Filter for direction.
+ #
+ if direction is not None:
+ allRels = [r for r in allRels if r.getDirection() == direction]
+
+ # Filter for relation type.
+ #
+ if relationType is None:
+ return allRels
+ else:
+ allRels = [r for r in allRels if r.getType() == relationType]
+
+ # Now filer for attribute type.
+ #
+ tmp = []
+ required = set(iter(requiredAttributes))
+
+ for r in allRels:
+ attrs = set(iter(r.getAttributes()))
+ if required.issubset(attrs):
+ tmp.append(r)
+ return tmp
+
+
+ def getRelationTargets(self, targetType=None, relationType=None,
+ requiredAttributes=(), direction=None):
+ """Returns a list of relation targets.
+
+ The arguments work exactly like in L{getRelations}, but
+ instead of L{Relation} objects, the matching relation
+ targets are returned. This can be L{Artist}, L{Release},
+ or L{Track} objects, depending on the relations.
+
+ As a special case, URL strings are returned if the target
+ is an URL.
+
+ @param targetType: a string containing an absolute URI, or None
+ @param relationType: a string containing an absolute URI, or None
+ @param requiredAttributes: a sequence containing absolute URIs
+ @param direction: one of L{Relation}'s direction constants
+ @return: a list of objects, depending on the relation
+
+ @see: L{getRelations}
+ """
+ ret = [ ]
+ rels = self.getRelations(targetType, relationType,
+ requiredAttributes, direction)
+
+ for r in rels:
+ if r.getTargetType() == Relation.TO_URL:
+ ret.append(r.getTargetId())
+ else:
+ ret.append(r.getTarget())
+
+ return ret
+
+
+ def addRelation(self, relation):
+ """Adds a relation.
+
+ This method adds C{relation} to the list of relations. The
+ given relation has to be initialized, at least the target
+ type has to be set.
+
+ @param relation: the L{Relation} object to add
+
+ @see: L{Entity}
+ """
+ assert relation.getType is not None
+ assert relation.getTargetType is not None
+ assert relation.getTargetId is not None
+ l = self._relations.setdefault(relation.getTargetType(), [ ])
+ l.append(relation)
+
+
+ def getRelationTargetTypes(self):
+ """Returns a list of target types available for this entity.
+
+ Use this to find out to which types of targets this entity
+ has relations. If the entity only has relations to tracks and
+ artists, for example, then a list containg the strings
+ L{Relation.TO_TRACK} and L{Relation.TO_ARTIST} is returned.
+
+ @return: a list of strings containing URIs
+
+ @see: L{getRelations}
+ """
+ return self._relations.keys()
+
+ def getTag(self, value):
+ """Return the tag with the given value (aka the tag's name).
+
+ @return: the L{Tag} with the given name or raises a KeyError
+ """
+ return self._tags[value]
+
+ def getTags(self):
+ """Return all tags attached to this Entity.
+
+ @return: a list of L{Tag} objects
+ """
+ return self._tags.values()
+
+ tags = property(getTags, doc='The tags for this entity.')
+
+ def addTag(self, tag):
+ """Add a new tag.
+
+ This merges an existing tag with the same name.
+
+ @param tag: the L{Tag} object to add
+
+ @see: L{getTags}
+ """
+ if self._tags.has_key(tag.value):
+ existing = self._tags[tag.value]
+ existing.count += tag.count
+ else:
+ self._tags[tag.value] = tag
+
+ def getRating(self):
+ """Return the rating of this Entity.
+ 0 = Unrated
+ 1 - 5 = Rating
+
+ @return: rating
+ """
+ return self._rating
+
+ rating = property(getRating, doc='The rating for this entity.')
+
+ def setRating(self, value):
+ self._rating = value
+
+
+class Artist(Entity):
+ """Represents an artist.
+
+ Artists in MusicBrainz can have a type. Currently, this type can
+ be either Person or Group for which the following URIs are assigned:
+
+ - C{http://musicbrainz.org/ns/mmd-1.0#Person}
+ - C{http://musicbrainz.org/ns/mmd-1.0#Group}
+
+ Use the L{TYPE_PERSON} and L{TYPE_GROUP} constants for comparison.
+ """
+ TYPE_PERSON = NS_MMD_1 + 'Person'
+ TYPE_GROUP = NS_MMD_1 + 'Group'
+
+ def __init__(self, id_=None, type_=None, name=None, sortName=None):
+ """Constructor.
+
+ @param id_: a string containing an absolute URI
+ @param type_: a string containing an absolute URI
+ @param name: a string containing the artist's name
+ @param sortName: a string containing the artist's sort name
+ """
+ Entity.__init__(self, id_)
+ self._type = type_
+ self._name = name
+ self._sortName = sortName
+ self._disambiguation = None
+ self._beginDate = None
+ self._endDate = None
+ self._aliases = [ ]
+ self._releases = [ ]
+ self._releasesCount = None
+ self._releasesOffset = None
+ self._releaseGroups = [ ]
+ self._releaseGroupsCount = None
+ self._releaseGroupsOffset = None
+
+ def getType(self):
+ """Returns the artist's type.
+
+ @return: a string containing an absolute URI, or None
+ """
+ return self._type
+
+ def setType(self, type_):
+ """Sets the artist's type.
+
+ @param type_: a string containing an absolute URI
+ """
+ self._type = type_
+
+ type = property(getType, setType, doc="The artist's type.")
+
+ def getName(self):
+ """Returns the artist's name.
+
+ @return: a string containing the artist's name, or None
+ """
+ return self._name
+
+ def setName(self, name):
+ """Sets the artist's name.
+
+ @param name: a string containing the artist's name
+ """
+ self._name = name
+
+ name = property(getName, setName, doc="The artist's name.")
+
+ def getSortName(self):
+ """Returns the artist's sort name.
+
+ The sort name is the artist's name in a special format which
+ is better suited for lexicographic sorting. The MusicBrainz
+ style guide specifies this format.
+
+ @see: U{The MusicBrainz Style Guidelines
+ }
+ """
+ return self._sortName
+
+ def setSortName(self, sortName):
+ """Sets the artist's sort name.
+
+ @param sortName: a string containing the artist's sort name
+
+ @see: L{getSortName}
+ """
+ self._sortName = sortName
+
+ sortName = property(getSortName, setSortName,
+ doc="The artist's sort name.")
+
+ def getDisambiguation(self):
+ """Returns the disambiguation attribute.
+
+ This attribute may be used if there is more than one artist
+ with the same name. In this case, disambiguation attributes
+ are added to the artists' names to keep them apart.
+
+ For example, there are at least three bands named 'Vixen'.
+ Each band has a different disambiguation in the MusicBrainz
+ database, like 'Hip-hop' or 'all-female rock/glam band'.
+
+ @return: a disambiguation string, or None
+
+ @see: L{getUniqueName}
+ """
+ return self._disambiguation
+
+ def setDisambiguation(self, disambiguation):
+ """Sets the disambiguation attribute.
+
+ @param disambiguation: a disambiguation string
+
+ @see: L{getDisambiguation}, L{getUniqueName}
+ """
+ self._disambiguation = disambiguation
+
+ disambiguation = property(getDisambiguation, setDisambiguation,
+ doc="The disambiguation comment.")
+
+ def getUniqueName(self):
+ """Returns a unique artist name (using disambiguation).
+
+ This method returns the artist name together with the
+ disambiguation attribute in parenthesis if it exists.
+ Example: 'Vixen (Hip-hop)'.
+
+ @return: a string containing the unique name
+
+ @see: L{getDisambiguation}
+ """
+ d = self.getDisambiguation()
+ if d is not None and d.strip() != '':
+ return '%s (%s)' % (self.getName(), d)
+ else:
+ return self.getName()
+
+ def getBeginDate(self):
+ """Returns the birth/foundation date.
+
+ The definition of the I{begin date} depends on the artist's
+ type. For persons, this is the day of birth, for groups it
+ is the day the group was founded.
+
+ The returned date has the format 'YYYY', 'YYYY-MM', or
+ 'YYYY-MM-DD', depending on how much detail is known.
+
+ @return: a string containing the date, or None
+
+ @see: L{getType}
+ """
+ return self._beginDate
+
+ def setBeginDate(self, dateStr):
+ """Sets the begin/foundation date.
+
+ @param dateStr: a date string
+
+ @see: L{getBeginDate}
+ """
+ self._beginDate = dateStr
+
+ beginDate = property(getBeginDate, setBeginDate,
+ doc="The begin/foundation date.")
+
+ def getEndDate(self):
+ """Returns the death/dissolving date.
+
+ The definition of the I{end date} depends on the artist's
+ type. For persons, this is the day of death, for groups it
+ is the day the group was dissolved.
+
+ @return: a string containing a date, or None
+
+ @see: L{getBeginDate}
+ """
+ return self._endDate
+
+ def setEndDate(self, dateStr):
+ """Sets the death/dissolving date.
+
+ @param dateStr: a string containing a date
+
+ @see: L{setEndDate}, L{getBeginDate}
+ """
+ self._endDate = dateStr
+
+ endDate = property(getEndDate, setEndDate,
+ doc="The death/dissolving date.")
+
+ def getAliases(self):
+ """Returns the list of aliases for this artist.
+
+ @return: a list of L{ArtistAlias} objects
+ """
+ return self._aliases
+
+ aliases = property(getAliases, doc='The list of aliases.')
+
+ def addAlias(self, alias):
+ """Adds an alias for this artist.
+
+ @param alias: an L{ArtistAlias} object
+ """
+ self._aliases.append(alias)
+
+ def getReleases(self):
+ """Returns a list of releases from this artist.
+
+ This may also include releases where this artist isn't the
+ I{main} artist but has just contributed one or more tracks
+ (aka VA-Releases).
+
+ @return: a list of L{Release} objects
+ """
+ return self._releases
+
+ releases = property(getReleases, doc='The list of releases')
+
+ def addRelease(self, release):
+ """Adds a release to this artist's list of releases.
+
+ @param release: a L{Release} object
+ """
+ self._releases.append(release)
+
+ def getReleasesOffset(self):
+ """Returns the offset of the release list.
+
+ This is used if the release list is incomplete (ie. the web
+ service only returned part of the release for this artist).
+ Note that the offset value is zero-based, which means release
+ C{0} is the first release.
+
+ @return: an integer containing the offset, or None
+
+ @see: L{getReleases}, L{getReleasesCount}
+ """
+ return self._releasesOffset
+
+ def setReleasesOffset(self, offset):
+ """Sets the offset of the release list.
+
+ @param offset: an integer containing the offset, or None
+
+ @see: L{getReleasesOffset}
+ """
+ self._releasesOffset = offset
+
+ releasesOffset = property(getReleasesOffset, setReleasesOffset,
+ doc='The offset of the release list.')
+
+ def getReleasesCount(self):
+ """Returns the number of existing releases.
+
+ This may or may not match with the number of elements that
+ L{getReleases} returns. If the count is higher than
+ the list, it indicates that the list is incomplete.
+
+ @return: an integer containing the count, or None
+
+ @see: L{setReleasesCount}, L{getReleasesOffset}
+ """
+ return self._releasesCount
+
+ def setReleasesCount(self, value):
+ """Sets the number of existing releases.
+
+ @param value: an integer containing the count, or None
+
+ @see: L{getReleasesCount}, L{setReleasesOffset}
+ """
+ self._releasesCount = value
+
+ releasesCount = property(getReleasesCount, setReleasesCount,
+ doc='The total number of releases')
+
+ def getReleaseGroups(self):
+ """Returns a list of release groups from this artist.
+
+ @return: a list of L{ReleaseGroup} objects
+ """
+ return self._releaseGroups
+
+ releaseGroups = property(getReleaseGroups, doc='The list of release groups')
+
+ def addReleaseGroup(self, releaseGroup):
+ """Adds a release group to this artist's list of release groups.
+
+ @param releaseGroup: a L{ReleaseGroup} object
+ """
+ self._releaseGroups.append(releaseGroup)
+
+ def getReleaseGroupsOffset(self):
+ """Returns the offset of the release group list.
+
+ This is used if the release group list is incomplete (ie. the
+ web service only returned part of the result for this artist).
+ Note that the offset value is zero-based, which means release
+ group C{0} is the first release group.
+
+ @return: an integer containing the offset, or None
+
+ @see: L{getReleaseGroups}, L{getReleaseGroupsCount}
+ """
+ return self._releaseGroupsOffset
+
+ def setReleaseGroupsOffset(self, offset):
+ """Sets the offset of the release group list.
+
+ @param offset: an integer containing the offset, or None
+
+ @see: L{getReleaseGroupsOffset}
+ """
+ self._releaseGroupsOffset = offset
+
+ releaseGroupsOffset = property(getReleaseGroupsOffset, setReleaseGroupsOffset,
+ doc='The offset of the release group list.')
+
+ def getReleaseGroupsCount(self):
+ """Returns the number of existing release groups.
+
+ This may or may not match with the number of elements that
+ L{getReleaseGroups} returns. If the count is higher than
+ the list, it indicates that the list is incomplete.
+
+ @return: an integer containing the count, or None
+
+ @see: L{setReleaseGroupsCount}, L{getReleaseGroupsOffset}
+ """
+ return self._releaseGroupsCount
+
+ def setReleaseGroupsCount(self, value):
+ """Sets the number of existing release groups.
+
+ @param value: an integer containing the count, or None
+
+ @see: L{getReleaseGroupsCount}, L{setReleaseGroupsOffset}
+ """
+ self._releaseGroupsCount = value
+
+ releasesCount = property(getReleaseGroupsCount, setReleaseGroupsCount,
+ doc='The total number of release groups')
+
+
+class Rating(object):
+ """The representation of a MusicBrain rating.
+
+ The rating can have the following values:
+
+ 0 = Unrated
+ [1..5] = Rating
+ """
+ def __init__(self, value=None, count=None):
+ """Constructor.
+
+ @param value: a string containing the tag's value
+ @param count: the number of users who added this tag
+ """
+ self._value = value
+ self._count = count
+
+ def getValue(self):
+ """Returns a string with the tag's value.
+
+ @return: an integer containing the rating's value, or None
+ """
+ return self._value
+
+ def setValue(self, value):
+ """ Set the value of this rating.
+
+ 0 or None = Clear your rating
+ 1 - 5 = Rating
+
+ @param value: the rating to apply
+
+ @raise ValueError: if value is not a double or not in the
+ range 0 - 5 or None.
+ """
+ if value == None:
+ value = 0
+ try:
+ value = float(value)
+ except ValueError, e:
+ raise ValueError("Value for rating needs to be an" \
+ "float.")
+ if value < 0.0 or value > 5.0:
+ raise ValueError("Value needs to be in the range [0..5]")
+ self._value = value
+
+ value = property(getValue, setValue, doc='The value of the rating.')
+
+ def getCount(self):
+ """Returns an integer containing the rating's frequency count.
+
+ @return: an integer containing the rating's frequency count,
+ or None
+ """
+ return self._count
+
+ def setCount(self, count):
+ """Sets the frequency count of this rating.
+
+ @param count: an integer containing the tag's frequency count
+ """
+ self._count = count
+
+ count = property(getCount, setCount, doc="This tag's frequency count.")
+
+ def __str__(self):
+ return str(self._value)
+
+ def __unicode__(self):
+ return unicode(self._value)
+
+
+class Tag(object):
+ """The representation of a MusicBrainz folksonomy tag.
+
+ The tag's value is the text that's displayed in the tag cloud.
+ The count attribute keeps track of how many users added the tag
+ to its owning entity.
+ """
+ def __init__(self, value=None, count=None):
+ """Constructor.
+
+ @param value: a string containing the tag's value
+ @param count: the number of users who added this tag
+ """
+ self._value = value
+ self._count = count
+
+ def getValue(self):
+ """Returns a string with the tag's value.
+
+ @return: a string containing the tags's value, or None
+ """
+ return self._value
+
+ def setValue(self, value):
+ """Sets the value of this tag.
+
+ @param value: A string containing the value of the tag
+ """
+ self._value = value
+
+ value = property(getValue, setValue, doc='The value of the text.')
+
+ def getCount(self):
+ """Returns an integer containing the tag's frequency count.
+
+ @return: an integer containing the tags's frequency count, or None
+ """
+ return self._count
+
+ def setCount(self, count):
+ """Sets the frequency count of this tag.
+
+ @param count: an integer containing the tag's frequency count
+ """
+ self._count = count
+
+ count = property(getCount, setCount, doc="This tag's frequency count.")
+
+ def __str__(self):
+ return str(self._value)
+
+ def __unicode__(self):
+ return unicode(self._value)
+
+
+class Label(Entity):
+ """Represents a record label.
+
+ A label within MusicBrainz is an L{Entity}. It contains information
+ about the label like when it was established, its name, label code and
+ other relationships. All release events may be assigned a label.
+ """
+ TYPE_UNKNOWN = NS_MMD_1 + 'Unknown'
+
+ TYPE_DISTRIBUTOR = NS_MMD_1 + 'Distributor'
+ TYPE_HOLDING = NS_MMD_1 + 'Holding'
+ TYPE_PRODUCTION = NS_MMD_1 + 'Production'
+
+ TYPE_ORIGINAL = NS_MMD_1 + 'OriginalProduction'
+ TYPE_BOOTLEG = NS_MMD_1 + 'BootlegProduction'
+ TYPE_REISSUE = NS_MMD_1 + 'ReissueProduction'
+
+ def __init__(self, id_=None):
+ """Constructor.
+
+ @param id_: a string containing an absolute URI
+ """
+ Entity.__init__(self, id_)
+ self._type = None
+ self._name = None
+ self._sortName = None
+ self._disambiguation = None
+ self._countryId = None
+ self._code = None
+ self._beginDate = None
+ self._endDate = None
+ self._aliases = [ ]
+
+ def getType(self):
+ """Returns the type of this label.
+
+ @return: a string containing an absolute URI
+ """
+ return self._type
+
+ def setType(self, type_):
+ """Sets the type of this label.
+
+ @param type_: A string containing the absolute URI of the type of label.
+ """
+ self._type = type_
+
+ type = property(getType, setType, doc='The type of label')
+
+ def getName(self):
+ """Returns a string with the name of the label.
+
+ @return: a string containing the label's name, or None
+ """
+ return self._name
+
+ def setName(self, name):
+ """Sets the name of this label.
+
+ @param name: A string containing the name of the label
+ """
+ self._name = name
+
+ name = property(getName, setName, doc='The name of the label.')
+
+ def getSortName(self):
+ """Returns the label's sort name.
+
+ The sort name is the label's name in a special format which
+ is better suited for lexicographic sorting. The MusicBrainz
+ style guide specifies this format.
+
+ @see: U{The MusicBrainz Style Guidelines
+ }
+ """
+ return self._sortName
+
+ def setSortName(self, sortName):
+ """Sets the label's sort name.
+
+ @param sortName: a string containing the label's sort name
+
+ @see: L{getSortName}
+ """
+ self._sortName = sortName
+
+ sortName = property(getSortName, setSortName,
+ doc="The label's sort name.")
+
+ def getDisambiguation(self):
+ """Returns the disambiguation attribute.
+
+ This attribute may be used if there is more than one label
+ with the same name. In this case, disambiguation attributes
+ are added to the labels' names to keep them apart.
+
+ @return: a disambiguation string, or None
+
+ @see: L{getUniqueName}
+ """
+ return self._disambiguation
+
+ def setDisambiguation(self, disambiguation):
+ """Sets the disambiguation attribute.
+
+ @param disambiguation: a disambiguation string
+
+ @see: L{getDisambiguation}, L{getUniqueName}
+ """
+ self._disambiguation = disambiguation
+
+ disambiguation = property(getDisambiguation, setDisambiguation,
+ doc="The disambiguation comment.")
+
+ def getUniqueName(self):
+ """Returns a unique label name (using disambiguation).
+
+ This method returns the label's name together with the
+ disambiguation attribute in parenthesis if it exists.
+
+ @return: a string containing the unique name
+
+ @see: L{getDisambiguation}
+ """
+ d = self.getDisambiguation()
+ if d is not None and d.strip() != '':
+ return '%s (%s)' % (self.getName(), d)
+ else:
+ return self.getName()
+
+ def getBeginDate(self):
+ """Returns the date this label was established.
+
+ @return: A string contained the start date, or None
+ """
+ return self._beginDate
+
+ def setBeginDate(self, date):
+ """Set the date this label was established.
+
+ @param date: A string in the format of YYYY-MM-DD
+ """
+ self._beginDate = date
+
+ beginDate = property(getBeginDate, setBeginDate,
+ doc='The date this label was established.')
+
+ def getEndDate(self):
+ """Returns the date this label closed.
+
+ The returned date has the format 'YYYY', 'YYYY-MM', or
+ 'YYYY-MM-DD', depending on how much detail is known.
+
+ @return: A string containing the date, or None
+ """
+ return self._endDate
+
+ def setEndDate(self, date):
+ """Set the date this label closed.
+
+ The date may have the format 'YYYY', 'YYYY-MM', or
+ 'YYYY-MM-DD', depending on how much detail is known.
+
+ @param date: A string containing the date, or None
+ """
+ self._endDate = date
+
+ endDate = property(getEndDate, setEndDate,
+ doc='The date this label closed.')
+
+ def getCountry(self):
+ """Returns the country the label is located.
+
+ @return: a string containing an ISO-3166 country code, or None
+
+ @see: L{musicbrainz2.utils.getCountryName}
+ """
+ return self._countryId
+
+ def setCountry(self, country):
+ """Sets the country the label is located.
+
+ @param country: a string containing an ISO-3166 country code
+ """
+ self._countryId = country
+
+ country = property(getCountry, setCountry,
+ doc='The country the label is located.')
+
+ def getCode(self):
+ """Returns the label code.
+
+ Label codes have been introduced by the IFPI (International
+ Federation of Phonogram and Videogram Industries) to uniquely
+ identify record labels. The label code consists of 'LC-' and 4
+ figures (currently being extended to 5 figures).
+
+ @return: a string containing the label code, or None
+ """
+ return self._code
+
+ def setCode(self, code):
+ """Sets the label code.
+
+ @param code: a string containing the label code
+ """
+ self._code = code
+
+ code = property(getCode, setCode,
+ doc='The label code.')
+
+ def getAliases(self):
+ """Returns the list of aliases for this label.
+
+ @return: a list of L{LabelAlias} objects
+ """
+ return self._aliases
+
+ aliases = property(getAliases, doc='The list of aliases.')
+
+ def addAlias(self, alias):
+ """Adds an alias for this label.
+
+ @param alias: a L{LabelAlias} object
+ """
+ self._aliases.append(alias)
+
+
+class Release(Entity):
+ """Represents a Release.
+
+ A release within MusicBrainz is an L{Entity} which contains L{Track}
+ objects. Releases may be of more than one type: There can be albums,
+ singles, compilations, live recordings, official releases, bootlegs
+ etc.
+
+ @note: The current MusicBrainz server implementation supports only a
+ limited set of types.
+ """
+ TYPE_NONE = NS_MMD_1 + 'None'
+ TYPE_NON_ALBUM_TRACKS = NS_MMD_1 + "NonAlbum Track"
+
+ TYPE_ALBUM = NS_MMD_1 + 'Album'
+ TYPE_SINGLE = NS_MMD_1 + 'Single'
+ TYPE_EP = NS_MMD_1 + 'EP'
+ TYPE_COMPILATION = NS_MMD_1 + 'Compilation'
+ TYPE_SOUNDTRACK = NS_MMD_1 + 'Soundtrack'
+ TYPE_SPOKENWORD = NS_MMD_1 + 'Spokenword'
+ TYPE_INTERVIEW = NS_MMD_1 + 'Interview'
+ TYPE_AUDIOBOOK = NS_MMD_1 + 'Audiobook'
+ TYPE_LIVE = NS_MMD_1 + 'Live'
+ TYPE_REMIX = NS_MMD_1 + 'Remix'
+ TYPE_OTHER = NS_MMD_1 + 'Other'
+
+ TYPE_OFFICIAL = NS_MMD_1 + 'Official'
+ TYPE_PROMOTION = NS_MMD_1 + 'Promotion'
+ TYPE_BOOTLEG = NS_MMD_1 + 'Bootleg'
+ TYPE_PSEUDO_RELEASE = NS_MMD_1 + 'Pseudo-Release'
+
+ def __init__(self, id_=None, title=None):
+ """Constructor.
+
+ @param id_: a string containing an absolute URI
+ @param title: a string containing the title
+ """
+ Entity.__init__(self, id_)
+ self._types = [ ]
+ self._title = title
+ self._textLanguage = None
+ self._textScript = None
+ self._asin = None
+ self._artist = None
+ self._releaseEvents = [ ]
+ #self._releaseEventsCount = None
+ self._releaseGroup = None
+ self._discs = [ ]
+ #self._discIdsCount = None
+ self._tracks = [ ]
+ self._tracksOffset = None
+ self._tracksCount = None
+
+
+ def getTypes(self):
+ """Returns the types of this release.
+
+ To test for release types, you can use the constants
+ L{TYPE_ALBUM}, L{TYPE_SINGLE}, etc.
+
+ @return: a list of strings containing absolute URIs
+
+ @see: L{musicbrainz2.utils.getReleaseTypeName}
+ """
+ return self._types
+
+ types = property(getTypes, doc='The list of types for this release.')
+
+ def addType(self, type_):
+ """Add a type to the list of types.
+
+ @param type_: a string containing absolute URIs
+
+ @see: L{getTypes}
+ """
+ self._types.append(type_)
+
+ def getTitle(self):
+ """Returns the release's title.
+
+ @return: a string containing the release's title
+ """
+ return self._title
+
+ def setTitle(self, title):
+ """Sets the release's title.
+
+ @param title: a string containing the release's title, or None
+ """
+ self._title = title
+
+ title = property(getTitle, setTitle, doc='The title of this release.')
+
+ def getTextLanguage(self):
+ """Returns the language used in release and track titles.
+
+ To represent the language, the ISO-639-2/T standard is used,
+ which provides three-letter terminological language codes like
+ 'ENG', 'DEU', 'JPN', 'KOR', 'ZHO' or 'YID'.
+
+ Note that this refers to release and track I{titles}, not
+ lyrics.
+
+ @return: a string containing the language code, or None
+
+ @see: L{musicbrainz2.utils.getLanguageName}
+ """
+ return self._textLanguage
+
+ def setTextLanguage(self, language):
+ """Sets the language used in releaes and track titles.
+
+ @param language: a string containing a language code
+
+ @see: L{getTextLanguage}
+ """
+ self._textLanguage = language
+
+ textLanguage = property(getTextLanguage, setTextLanguage,
+ doc='The language used in release and track titles.')
+
+ def getTextScript(self):
+ """Returns the script used in release and track titles.
+
+ To represent the script, ISO-15924 script codes are used.
+ Valid codes are, among others: 'Latn', 'Cyrl', 'Hans', 'Hebr'
+
+ Note that this refers to release and track I{titles}, not
+ lyrics.
+
+ @return: a string containing the script code, or None
+
+ @see: L{musicbrainz2.utils.getScriptName}
+ """
+ return self._textScript
+
+ def setTextScript(self, script):
+ """Sets the script used in releaes and track titles.
+
+ @param script: a string containing a script code
+
+ @see: L{getTextScript}
+ """
+ self._textScript = script
+
+ textScript = property(getTextScript, setTextScript,
+ doc='The script used in release and track titles.')
+
+ def getAsin(self):
+ """Returns the amazon shop identifier (ASIN).
+
+ The ASIN is a 10-letter code (except for books) assigned
+ by Amazon, which looks like 'B000002IT2' or 'B00006I4YD'.
+
+ @return: a string containing the ASIN, or None
+ """
+ return self._asin
+
+ def setAsin(self, asin):
+ """Sets the amazon shop identifier (ASIN).
+
+ @param asin: a string containing the ASIN
+
+ @see: L{getAsin}
+ """
+ self._asin = asin
+
+ asin = property(getAsin, setAsin, doc='The amazon shop identifier.')
+
+ def getArtist(self):
+ """Returns the main artist of this release.
+
+ @return: an L{Artist} object, or None
+ """
+ return self._artist
+
+ def setArtist(self, artist):
+ """Sets this release's main artist.
+
+ @param artist: an L{Artist} object
+ """
+ self._artist = artist
+
+ artist = property(getArtist, setArtist,
+ doc='The main artist of this release.')
+
+ def getReleaseGroup(self):
+ """Returns the release group to which this release belongs.
+
+ @return: a L{ReleaseGroup} object, or None.
+ """
+ return self._releaseGroup
+
+ def setReleaseGroup(self, releaseGroup):
+ """Sets the release's release group.
+
+ @param releaseGroup: a L{ReleaseGroup} object, or None.
+ """
+ self._releaseGroup = releaseGroup
+
+ releaseGroup = property(getReleaseGroup, setReleaseGroup,
+ doc='The release group this release belongs to.')
+
+ def isSingleArtistRelease(self):
+ """Checks if this is a single artist's release.
+
+ Returns C{True} if the release's main artist (L{getArtist}) is
+ also the main artist for all of the tracks. This is checked by
+ comparing the artist IDs.
+
+ Note that the release's artist has to be set (see L{setArtist})
+ for this. The track artists may be unset.
+
+ @return: True, if this is a single artist's release
+ """
+ releaseArtist = self.getArtist()
+ assert releaseArtist is not None, 'Release Artist may not be None!'
+ for track in self.getTracks():
+ if track.getArtist() is None:
+ continue
+ if track.getArtist().getId() != releaseArtist.getId():
+ return False
+
+ return True
+
+ def getTracks(self):
+ """Returns the tracks this release contains.
+
+ @return: a list containing L{Track} objects
+
+ @see: L{getTracksOffset}, L{getTracksCount}
+ """
+ return self._tracks
+
+ tracks = property(getTracks, doc='The list of tracks.')
+
+ def addTrack(self, track):
+ """Adds a track to this release.
+
+ This appends a track at the end of this release's track list.
+
+ @param track: a L{Track} object
+ """
+ self._tracks.append(track)
+
+ def getTracksOffset(self):
+ """Returns the offset of the track list.
+
+ This is used if the track list is incomplete (ie. the web
+ service only returned part of the tracks on this release).
+ Note that the offset value is zero-based, which means track
+ C{0} is the first track.
+
+ @return: an integer containing the offset, or None
+
+ @see: L{getTracks}, L{getTracksCount}
+ """
+ return self._tracksOffset
+
+ def setTracksOffset(self, offset):
+ """Sets the offset of the track list.
+
+ @param offset: an integer containing the offset, or None
+
+ @see: L{getTracksOffset}, L{setTracksCount}
+ """
+ self._tracksOffset = offset
+
+ tracksOffset = property(getTracksOffset, setTracksOffset,
+ doc='The offset of the track list.')
+
+ def getTracksCount(self):
+ """Returns the number of tracks on this release.
+
+ This may or may not match with the number of elements that
+ L{getTracks} returns. If the count is higher than
+ the list, it indicates that the list is incomplete.
+
+ @return: an integer containing the count, or None
+
+ @see: L{setTracksCount}, L{getTracks}, L{getTracksOffset}
+ """
+ return self._tracksCount
+
+ def setTracksCount(self, value):
+ """Sets the number of tracks on this release.
+
+ @param value: an integer containing the count, or None
+
+ @see: L{getTracksCount}, L{setTracksOffset}
+ """
+ self._tracksCount = value
+
+ tracksCount = property(getTracksCount, setTracksCount,
+ doc='The total number of releases')
+
+
+ def getReleaseEvents(self):
+ """Returns the list of release events.
+
+ A L{Release} may contain a list of so-called release events,
+ each represented using a L{ReleaseEvent} object. Release
+ evens specify where and when this release was, well, released.
+
+ @return: a list of L{ReleaseEvent} objects
+
+ @see: L{getReleaseEventsAsDict}
+ """
+ return self._releaseEvents
+
+ releaseEvents = property(getReleaseEvents,
+ doc='The list of release events.')
+
+ def addReleaseEvent(self, event):
+ """Adds a release event to this release.
+
+ @param event: a L{ReleaseEvent} object
+
+ @see: L{getReleaseEvents}
+ """
+ self._releaseEvents.append(event)
+
+ def getReleaseEventsAsDict(self):
+ """Returns the release events represented as a dict.
+
+ Keys are ISO-3166 country codes like 'DE', 'UK', 'FR' etc.
+ Values are dates in 'YYYY', 'YYYY-MM' or 'YYYY-MM-DD' format.
+
+ @return: a dict containing (countryCode, date) entries
+
+ @see: L{getReleaseEvents}, L{musicbrainz2.utils.getCountryName}
+ """
+ d = { }
+ for event in self.getReleaseEvents():
+ d[event.getCountry()] = event.getDate()
+ return d
+
+ def getEarliestReleaseDate(self):
+ """Returns the earliest release date.
+
+ This favours complete dates. For example, '2006-09' is
+ returned if there is '2000', too. If there is no release
+ event associated with this release, None is returned.
+
+ @return: a string containing the date, or None
+
+ @see: L{getReleaseEvents}, L{getReleaseEventsAsDict}
+ """
+ event = self.getEarliestReleaseEvent()
+
+ if event is None:
+ return None
+ else:
+ return event.getDate()
+
+ def getEarliestReleaseEvent(self):
+ """Returns the earliest release event.
+
+ This works like L{getEarliestReleaseDate}, but instead of
+ just the date, this returns a L{ReleaseEvent} object.
+
+ @return: a L{ReleaseEvent} object, or None
+
+ @see: L{getReleaseEvents}, L{getEarliestReleaseDate}
+ """
+ dates = [ ]
+ for event in self.getReleaseEvents():
+ date = event.getDate()
+ if len(date) == 10: # 'YYYY-MM-DD'
+ dates.append( (date, event) )
+ elif len(date) == 7: # 'YYYY-MM'
+ dates.append( (date + '-99', event) )
+ else:
+ dates.append( (date + '-99-99', event) )
+
+ dates.sort(lambda x, y: cmp(x[0], y[0]))
+
+ if len(dates) > 0:
+ return dates[0][1]
+ else:
+ return None
+
+
+ #def getReleaseEventsCount(self):
+ # """Returns the number of release events.
+ #
+ # This may or may not match with the number of elements that
+ # getReleaseEvents() returns. If the count is higher than
+ # the list, it indicates that the list is incomplete.
+ # """
+ # return self._releaseEventsCount
+
+ #def setReleaseEventsCount(self, value):
+ # self._releaseEventsCount = value
+
+ def getDiscs(self):
+ """Returns the discs associated with this release.
+
+ Discs are currently containers for MusicBrainz DiscIDs.
+ Note that under rare circumstances (identical TOCs), a
+ DiscID could be associated with more than one release.
+
+ @return: a list of L{Disc} objects
+ """
+ return self._discs
+
+ discs = property(getDiscs, doc='The list of associated discs.')
+
+ def addDisc(self, disc):
+ """Adds a disc to this release.
+
+ @param disc: a L{Disc} object
+ """
+ self._discs.append(disc)
+
+ #def getDiscIdsCount(self):
+ # return self._discIdsCount
+
+ #def setDiscIdsCount(self, value):
+ # self._discIdsCount = value
+
+
+class ReleaseGroup(Entity):
+ """Represents a ReleaseGroup.
+
+ A ReleaseGroup in MusicBrainz is an L{Entity} which groups several different
+ versions of L{Release} objects (e.g., different editions of the same album).
+
+ @see: L{Release}
+ @see: L{Entity}
+ """
+
+ def __init__(self, id_=None, title=None):
+ """Constructor.
+
+ @param id_: a string containing an absolute URI
+ @param title: a string containing the title
+ """
+ Entity.__init__(self, id_)
+ self._title = title
+ self._id = id_
+ self._type = None
+ self._releases = [ ]
+ self._artist = None
+ self._releasesOffset = 0
+ self._releasesCount = 0
+
+ def getType(self):
+ """Returns the type of this release group.
+
+ To test for release types, you can use the constants
+ L{Release.TYPE_ALBUM}, L{Release.TYPE_SINGLE}, etc.
+
+ @return: a string containing an absolute URI, or None.
+
+ @see: L{musicbrainz2.utils.getReleaseTypeName}
+ """
+ return self._type
+
+ def setType(self, type_):
+ """Sets the type of this release group.
+
+ Use a constant from the L{Release} class, such as
+ L{Release.TYPE_ALBUM} or L{Release.TYPE_SINGLE} to
+ set the value.
+
+ @param type_: a string containing an absolute URI, or None.
+
+ @see: L{musicbrainz2.utils.getReleaseTypeName}
+ """
+ self._type = type_
+
+ type = property(getType, setType,
+ doc = 'The type of this release group.')
+
+ def getReleases(self):
+ """Gets the releases in this release group.
+
+ @return: a list of L{Release} objects
+ @see: L{Release}
+ """
+ return self._releases
+
+ releases = property(getReleases,
+ doc = 'The list of releases in this release group.')
+
+ def addRelease(self, release):
+ """Adds a L{Release} to this release group.
+
+ @param release: a L{Release} object
+ """
+ self._releases.append(release)
+
+ def getReleasesOffset(self):
+ """Returns the offset of the release list.
+
+ This is used if the release list is incomplete (i.e., the web
+ service only returned a portion of the releases in this release
+ group).
+
+ @return: an integer containing the offset, or None.
+ @see: L{getReleases}, L{getReleasesCount}
+ """
+ return self._releasesOffset
+
+ def setReleasesOffset(self, offset):
+ """Sets the offset of the release list.
+
+ @param offset: an integer containing the offset, or None.
+ @see: L{getReleases}, L{getReleasesOffset}
+ """
+ self._releasesOffset = offset
+
+ releasesOffset = property(getReleasesOffset, setReleasesOffset,
+ doc='The offset of the release list.')
+
+ def getReleasesCount(self):
+ """Returns the number of releases in this release group.
+
+ This may or may not match the number of elements returned by
+ L{getReleases}. If the count is higher than the length of that
+ list, then the list is incomplete.
+
+ @return: an integer containing the count, or None
+ @see: L{getReleases}, L{setReleasesCount}, L{getReleasesOffset}
+ """
+ return self._releasesCount
+
+ def setReleasesCount(self, value):
+ """Sets the number of releases in this release group.
+
+ @param value: an integer containing the count, or None.
+ @see: L{getReleases}, L{getReleasesCount}, L{getReleasesOffset}
+ """
+ self._releasesCount = value
+
+ releasesCount = property(getReleasesCount, setReleasesCount,
+ doc = 'The total number of releases')
+
+ def getTitle(self):
+ """Returns this release group's title.
+
+ @return: a string containing the release group's title
+ """
+ return self._title
+
+ def setTitle(self, title):
+ """Sets the release group's title.
+
+ @param title: a string containing the release group's title.
+ """
+ self._title = title
+
+ title = property(getTitle, setTitle,
+ doc = 'The title of this release group.')
+
+ def getArtist(self):
+ """Returns the main artist of this release group.
+
+ @return: an L{Artist} object, or None
+ """
+ return self._artist
+
+ def setArtist(self, artist):
+ """Sets the release group's main artist.
+
+ @param artist: an L{Artist} object
+ """
+ self._artist = artist
+
+ artist = property(getArtist, setArtist,
+ doc = 'The main artist of this release group')
+
+
+class Track(Entity):
+ """Represents a track.
+
+ This class represents a track which may appear on one or more releases.
+ A track may be associated with exactly one artist (the I{main} artist).
+
+ Using L{getReleases}, you can find out on which releases this track
+ appears. To get the track number, too, use the
+ L{Release.getTracksOffset} method.
+
+ @note: Currently, the MusicBrainz server doesn't support tracks to
+ be on more than one release.
+
+ @see: L{Release}, L{Artist}
+ """
+ def __init__(self, id_=None, title=None):
+ """Constructor.
+
+ @param id_: a string containing an absolute URI
+ @param title: a string containing the title
+ """
+ Entity.__init__(self, id_)
+ self._title = title
+ self._artist = None
+ self._duration = None
+ self._puids = [ ]
+ self._releases = [ ]
+ self._isrcs = [ ]
+
+ def getTitle(self):
+ """Returns the track's title.
+
+ The style and format of this attribute is specified by the
+ style guide.
+
+ @return: a string containing the title, or None
+
+ @see: U{The MusicBrainz Style Guidelines
+ }
+ """
+ return self._title
+
+ def setTitle(self, title):
+ """Sets the track's title.
+
+ @param title: a string containing the title
+
+ @see: L{getTitle}
+ """
+ self._title = title
+
+ title = property(getTitle, setTitle, doc="The track's title.")
+
+ def getArtist(self):
+ """Returns the main artist of this track.
+
+ @return: an L{Artist} object, or None
+ """
+ return self._artist
+
+ def setArtist(self, artist):
+ """Sets this track's main artist.
+
+ @param artist: an L{Artist} object
+ """
+ self._artist = artist
+
+ artist = property(getArtist, setArtist, doc="The track's main artist.")
+
+ def getDuration(self):
+ """Returns the duration of this track in milliseconds.
+
+ @return: an int containing the duration in milliseconds, or None
+ """
+ return self._duration
+
+ def setDuration(self, duration):
+ """Sets the duration of this track in milliseconds.
+
+ @param duration: an int containing the duration in milliseconds
+ """
+ self._duration = duration
+
+ duration = property(getDuration, setDuration,
+ doc='The duration in milliseconds.')
+
+ def getDurationSplit(self):
+ """Returns the duration as a (minutes, seconds) tuple.
+
+ If no duration is set, (0, 0) is returned. Seconds are
+ rounded towards the ceiling if at least 500 milliseconds
+ are left.
+
+ @return: a (minutes, seconds) tuple, both entries being ints
+ """
+ duration = self.getDuration()
+ if duration is None:
+ return (0, 0)
+ else:
+ seconds = int( round(duration / 1000.0) )
+ return (seconds / 60, seconds % 60)
+
+ def getPuids(self):
+ """Returns the PUIDs associated with this track.
+
+ Please note that a PUID may be associated with more than one
+ track.
+
+ @return: a list of strings, each containing one PUID
+ """
+ return self._puids
+
+ puids = property(getPuids, doc='The list of associated PUIDs.')
+
+ def addPuid(self, puid):
+ """Add a PUID to this track.
+
+ @param puid: a string containing a PUID
+ """
+ self._puids.append(puid)
+
+ def getISRCs(self):
+ """Returns the ISRCs associated with this track.
+
+ @return: a list of strings, each containing one ISRC
+ """
+ return self._isrcs
+
+ isrcs = property(getISRCs, doc='The list of associated ISRCs')
+
+ def addISRC(self, isrc):
+ """Add a ISRC to this track.
+
+ @param isrc: a string containing an ISRC
+ """
+ self._isrcs.append(isrc)
+
+ def getReleases(self):
+ """Returns the list of releases this track appears on.
+
+ @return: a list of L{Release} objects
+ """
+ return self._releases
+
+ releases = property(getReleases,
+ doc='The releases on which this track appears.')
+
+ def addRelease(self, release):
+ """Add a release on which this track appears.
+
+ @param release: a L{Release} object
+ """
+ self._releases.append(release)
+
+
+class Relation(object):
+ """Represents a relation between two Entities.
+
+ There may be an arbitrary number of relations between all first
+ class objects in MusicBrainz. The Relation itself has multiple
+ attributes, which may or may not be used for a given relation
+ type.
+
+ Note that a L{Relation} object only contains the target but not
+ the source end of the relation.
+
+ @todo: Add some examples.
+
+ @cvar TO_ARTIST: Identifies relations linking to an artist.
+ @cvar TO_RELEASE: Identifies relations linking to a release.
+ @cvar TO_TRACK: Identifies relations linking to a track.
+ @cvar TO_URL: Identifies relations linking to an URL.
+
+ @cvar DIR_NONE: Relation reading direction doesn't matter.
+ @cvar DIR_FORWARD: Relation reading direction is from source to target.
+ @cvar DIR_BACKWARD: Relation reading direction is from target to source.
+ @cvar DIR_BOTH: Relation reading direction doesn't matter (no longer used!).
+ """
+ # Relation target types
+ #
+ TO_ARTIST = NS_REL_1 + 'Artist'
+ TO_RELEASE = NS_REL_1 + 'Release'
+ TO_TRACK = NS_REL_1 + 'Track'
+ TO_URL = NS_REL_1 + 'Url'
+
+ # Relation reading directions
+ #
+ DIR_BOTH = 'both'
+ DIR_FORWARD = 'forward'
+ DIR_BACKWARD = 'backward'
+ DIR_NONE = 'none'
+
+ def __init__(self, relationType=None, targetType=None, targetId=None,
+ direction=DIR_NONE, attributes=None,
+ beginDate=None, endDate=None, target=None):
+ """Constructor.
+
+ @param relationType: a string containing an absolute URI
+ @param targetType: a string containing an absolute URI
+ @param targetId: a string containing an absolute URI
+ @param direction: one of C{Relation.DIR_FORWARD},
+ C{Relation.DIR_BACKWARD}, or C{Relation.DIR_NONE}
+ @param attributes: a list of strings containing absolute URIs
+ @param beginDate: a string containing a date
+ @param endDate: a string containing a date
+ @param target: an instance of a subclass of L{Entity}
+ """
+ self._relationType = relationType
+ self._targetType = targetType
+ self._targetId = targetId
+ self._direction = direction
+ self._beginDate = beginDate
+ self._endDate = endDate
+ self._target = target
+ self._attributes = attributes
+ if self._attributes is None:
+ self._attributes = [ ]
+
+ def getType(self):
+ """Returns this relation's type.
+
+ @return: a string containing an absolute URI, or None
+ """
+ return self._relationType
+
+ def setType(self, type_):
+ """Sets this relation's type.
+
+ @param type_: a string containing an absolute URI
+ """
+ self._relationType = type_
+
+ type = property(getType, setType, doc="The relation's type.")
+
+ def getTargetId(self):
+ """Returns the target's ID.
+
+ This is the ID the relation points to. It is an absolute
+ URI, and in case of an URL relation, it is a URL.
+
+ @return: a string containing an absolute URI
+ """
+ return self._targetId
+
+ def setTargetId(self, targetId):
+ """Sets the target's ID.
+
+ @param targetId: a string containing an absolute URI
+
+ @see: L{getTargetId}
+ """
+ self._targetId = targetId
+
+ targetId = property(getTargetId, setTargetId, doc="The target's ID.")
+
+ def getTargetType(self):
+ """Returns the target's type.
+
+ For MusicBrainz data, the following target types are defined:
+ - artists: L{Relation.TO_ARTIST}
+ - releases: L{Relation.TO_RELEASE}
+ - tracks: L{Relation.TO_TRACK}
+ - urls: L{Relation.TO_URL}
+
+ @return: a string containing an absolute URI
+ """
+ return self._targetType
+
+ def setTargetType(self, targetType):
+ """Sets the target's type.
+
+ @param targetType: a string containing an absolute URI
+
+ @see: L{getTargetType}
+ """
+ self._targetType = targetType
+
+ targetId = property(getTargetId, setTargetId,
+ doc="The type of target this relation points to.")
+
+ def getAttributes(self):
+ """Returns a list of attributes describing this relation.
+
+ The attributes permitted depend on the relation type.
+
+ @return: a list of strings containing absolute URIs
+ """
+ return self._attributes
+
+ attributes = property(getAttributes,
+ doc='The list of attributes describing this relation.')
+
+ def addAttribute(self, attribute):
+ """Adds an attribute to the list.
+
+ @param attribute: a string containing an absolute URI
+ """
+ self._attributes.append(attribute)
+
+ def getBeginDate(self):
+ """Returns the begin date.
+
+ The definition depends on the relation's type. It may for
+ example be the day of a marriage or the year an artist
+ joined a band. For other relation types this may be
+ undefined.
+
+ @return: a string containing a date
+ """
+ return self._beginDate
+
+ def setBeginDate(self, dateStr):
+ """Sets the begin date.
+
+ @param dateStr: a string containing a date
+
+ @see: L{getBeginDate}
+ """
+ self._beginDate = dateStr
+
+ beginDate = property(getBeginDate, setBeginDate, doc="The begin date.")
+
+ def getEndDate(self):
+ """Returns the end date.
+
+ As with the begin date, the definition depends on the
+ relation's type. Depending on the relation type, this may
+ or may not be defined.
+
+ @return: a string containing a date
+
+ @see: L{getBeginDate}
+ """
+ return self._endDate
+
+ def setEndDate(self, dateStr):
+ """Sets the end date.
+
+ @param dateStr: a string containing a date
+
+ @see: L{getBeginDate}
+ """
+ self._endDate = dateStr
+
+ endDate = property(getEndDate, setEndDate, doc="The end date.")
+
+ def getDirection(self):
+ """Returns the reading direction.
+
+ The direction may be one of L{Relation.DIR_FORWARD},
+ L{Relation.DIR_BACKWARD}, or L{Relation.DIR_NONE},
+ depending on how the relation should be read. For example,
+ if direction is L{Relation.DIR_FORWARD} for a cover relation,
+ it is read as "X is a cover of Y". For some relations there is
+ no reading direction (like marriages) and the web service doesn't
+ send a direction. In these cases, the direction is set to
+ L{Relation.DIR_NONE}.
+
+ @return: L{Relation.DIR_FORWARD}, L{Relation.DIR_BACKWARD},
+ or L{Relation.DIR_NONE}
+ """
+ return self._direction
+
+ def setDirection(self, direction):
+ """Sets the reading direction.
+
+ @param direction: L{Relation.DIR_FORWARD},
+ L{Relation.DIR_BACKWARD}, or L{Relation.DIR_NONE}
+
+ @see: L{getDirection}
+ """
+ self._direction = direction
+
+ direction = property(getDirection, setDirection,
+ doc="The reading direction.")
+
+ def getTarget(self):
+ """Returns this relation's target object.
+
+ Note that URL relations never have a target object. Use the
+ L{getTargetId} method to get the URL.
+
+ @return: a subclass of L{Entity}, or None
+ """
+ return self._target
+
+ def setTarget(self, target):
+ """Sets this relation's target object.
+
+ Note that URL relations never have a target object, they
+ are set using L{setTargetId}.
+
+ @param target: a subclass of L{Entity}
+ """
+ self._target = target
+
+ target = property(getTarget, setTarget,
+ doc="The relation's target object.")
+
+
+class ReleaseEvent(object):
+ """A release event, indicating where and when a release took place.
+
+ All country codes used must be valid ISO-3166 country codes (i.e. 'DE',
+ 'UK' or 'FR'). The dates are strings and must have the format 'YYYY',
+ 'YYYY-MM' or 'YYYY-MM-DD'.
+
+ The format of the release medium is a URI that can be compared to the
+ constants on this class (L{FORMAT_CD}, L{FORMAT_DVD} and others).
+ """
+ FORMAT_CD = NS_MMD_1 + 'CD'
+ FORMAT_DVD = NS_MMD_1 + 'DVD'
+ FORMAT_SACD = NS_MMD_1 + 'SACD'
+ FORMAT_DUALDISC = NS_MMD_1 + 'DualDisc'
+ FORMAT_LASERDISC = NS_MMD_1 + 'LaserDisc'
+ FORMAT_MINIDISC = NS_MMD_1 + 'MiniDisc'
+ FORMAT_VINYL = NS_MMD_1 + 'Vinyl'
+ FORMAT_CASSETTE = NS_MMD_1 + 'Cassette'
+ FORMAT_CARTRIDGE = NS_MMD_1 + 'Cartridge'
+ FORMAT_REEL_TO_REEL = NS_MMD_1 + 'ReelToReel'
+ FORMAT_DAT = NS_MMD_1 + 'DAT'
+ FORMAT_DIGITAL = NS_MMD_1 + 'Digital'
+ FORMAT_WAX_CYLINDER = NS_MMD_1 + 'WaxCylinder'
+ FORMAT_PIANO_ROLL = NS_MMD_1 + 'PianoRoll'
+ FORMAT_OTHER = NS_MMD_1 + 'Other'
+
+ def __init__(self, country=None, dateStr=None):
+ """Constructor.
+
+ @param country: a string containing an ISO-3166 country code
+ @param dateStr: a string containing a date string
+ """
+ self._countryId = country
+ self._dateStr = dateStr
+ self._catalogNumber = None
+ self._barcode = None
+ self._label = None
+ self._format = None
+
+ def getCountry(self):
+ """Returns the country a release took place.
+
+ @note: Due to a server limitation, the web service does not
+ return country IDs for release collection queries. This only
+ affects the L{musicbrainz2.webservice.Query.getReleases} query.
+
+ @return: a string containing an ISO-3166 country code, or None
+
+ @see: L{musicbrainz2.utils.getCountryName}
+ """
+ return self._countryId
+
+ def setCountry(self, country):
+ """Sets the country a release took place.
+
+ @param country: a string containing an ISO-3166 country code
+ """
+ self._countryId = country
+
+ country = property(getCountry, setCountry,
+ doc='The country a release took place.')
+
+ def getCatalogNumber(self):
+ """Returns the catalog number of this release event.
+
+ @return: A string containing the catalog number, or None
+ """
+ return self._catalogNumber
+
+ def setCatalogNumber(self, catalogNumber):
+ """Sets the catalog number of this release event.
+
+ @param catalogNumber: A string containing the catalog number
+ """
+ self._catalogNumber = catalogNumber
+
+ catalogNumber = property(getCatalogNumber, setCatalogNumber,
+ doc='The catalog number of the release event')
+
+ def getBarcode(self):
+ """Returns the barcode of this release event.
+
+ @return: A string containing the barcode, or None
+ """
+ return self._barcode
+
+ def setBarcode(self, barcode):
+ """Sets the barcode of this release event.
+
+ @param barcode: A string containing the barcode
+ """
+ self._barcode = barcode
+
+ barcode = property(getBarcode, setBarcode,
+ doc='The barcode of the release event')
+
+ def getLabel(self):
+ """Returns a L{Label} object for the label associated with this release.
+
+ @return: a L{Label} object, or None
+ """
+ return self._label
+
+ def setLabel(self, label):
+ """Sets the label of this release event.
+
+ @param label: A L{Label} object
+ """
+ self._label = label
+
+ label = property(getLabel, setLabel, doc='The label of the release')
+
+ def getDate(self):
+ """Returns the date a release took place.
+
+ @return: a string containing a date
+ """
+ return self._dateStr
+
+ def setDate(self, dateStr):
+ """Sets the date a release took place.
+
+ @param dateStr: a string containing a date
+ """
+ self._dateStr = dateStr
+
+ date = property(getDate, setDate, doc='The date a release took place.')
+
+ def getFormat(self):
+ """Returns the format of the release medium.
+
+ @return: a string containing a URI, or None
+ """
+ return self._format
+
+ def setFormat(self, format):
+ """Sets the format of the release medium.
+
+ @param format: a string containing a URI
+ """
+ self._format = format
+
+ format = property(getFormat, setFormat,
+ doc='The format of the release medium.')
+
+
+class CDStub(object):
+ """Represents a CD Stub"""
+
+ def __init__(self, disc):
+ """Constructor.
+
+ @param disc: a L{Disc} object to create this CD Stub from
+ """
+ assert isinstance(disc, Disc), 'musicbrainz2.model.Disc expected'
+ self._disc = disc
+ self._tracks = [ ]
+ self._title = ""
+ self._artist = ""
+ self._barcode = ""
+ self._comment = ""
+
+ def setTitle(self, title):
+ """Sets the title of this release.
+
+ @param title: a string containing the title
+ """
+ self._title = title
+
+ def getTitle(self):
+ """Returns the title of this release.
+
+ @return: a string containing the title
+ """
+ return self._title
+
+ title = property(getTitle, setTitle,
+ doc='The title of the release')
+
+ def setArtist(self, artist):
+ """Sets the artist of this release.
+
+ @param artist: a string containing the artist
+ """
+ self._artist = artist
+
+ def getArtist(self):
+ """Returns the artist of this release.
+
+ @return: a string containing the artist
+ """
+ return self._artist
+
+ artist = property(getArtist, setArtist,
+ doc='The artist of the release')
+
+ def setComment(self, comment):
+ """Sets the comment for this release.
+
+ @param comment: a string containing the comment
+ """
+ self._comment = comment
+
+ def getComment(self):
+ """Returns the comment for this release.
+
+ @return: a string containing the comment
+ """
+ return self._comment
+
+ comment = property(getComment, setComment,
+ doc='Comment for the release (optional)')
+
+ def setBarcode(self, barcode):
+ """Sets the barcode of this release.
+
+ @param barcode: a string containing the barcode
+ """
+ self._barcode = barcode
+
+ def getBarcode(self):
+ """Returns the barcode of this release.
+
+ @return: a string containing the barcode
+ """
+ return self._barcode
+
+ barcode = property(getBarcode, setBarcode,
+ doc='Barcode for the release (optional)')
+
+ def addTrack(self, title, artist=''):
+ """Add a track to this release
+
+ @param title: a string containing the title of the track
+ @param artist: a string containing the artist of the track,
+ if different to the album artist
+ """
+ self._tracks.append((title, artist))
+
+ def getTracks(self):
+ """Return all the tracks on the release.
+
+ @return: a list of tuples containing (title, artist) pairs
+ for each track
+ """
+ return self._tracks
+
+ tracks = property(getTracks, doc='The tracks of the release.')
+
+class Disc(object):
+ """Represents an Audio CD.
+
+ This class represents an Audio CD. A disc can have an ID (the
+ MusicBrainz DiscID), which is calculated from the CD's table of
+ contents (TOC). There may also be data from the TOC like the length
+ of the disc in sectors, as well as position and length of the tracks.
+
+ Note that different TOCs, maybe due to different pressings, lead to
+ different DiscIDs. Conversely, if two different discs have the same
+ TOC, they also have the same DiscID (which is unlikely but not
+ impossible). DiscIDs are always 28 characters long and look like this:
+ C{'J68I_CDcUFdCRCIbHSEbTBCbooA-'}. Sometimes they are also referred
+ to as CDIndex IDs.
+
+ The L{MusicBrainz web service } only returns
+ the DiscID and the number of sectors. The DiscID calculation function
+ L{musicbrainz2.disc.readDisc}, however, can retrieve the other
+ attributes of L{Disc} from an Audio CD in the disc drive.
+ """
+ def __init__(self, id_=None):
+ """Constructor.
+
+ @param id_: a string containing a 28-character DiscID
+ """
+ self._id = id_
+ self._sectors = None
+ self._firstTrackNum = None
+ self._lastTrackNum = None
+ self._tracks = [ ]
+
+ def getId(self):
+ """Returns the MusicBrainz DiscID.
+
+ @return: a string containing a 28-character DiscID
+ """
+ return self._id
+
+ def setId(self, id_):
+ """Sets the MusicBrainz DiscId.
+
+ @param id_: a string containing a 28-character DiscID
+ """
+ self._id = id_
+
+ id = property(getId, setId, doc="The MusicBrainz DiscID.")
+
+ def getSectors(self):
+ """Returns the length of the disc in sectors.
+
+ @return: the length in sectors as an integer, or None
+ """
+ return self._sectors
+
+ def setSectors(self, sectors):
+ """Sets the length of the disc in sectors.
+
+ @param sectors: the length in sectors as an integer
+ """
+ self._sectors = sectors
+
+ sectors = property(getSectors, setSectors,
+ doc="The length of the disc in sectors.")
+
+ def getFirstTrackNum(self):
+ """Returns the number of the first track on this disc.
+
+ @return: an int containing the track number, or None
+ """
+ return self._firstTrackNum
+
+ def setFirstTrackNum(self, trackNum):
+ """Sets the number of the first track on this disc.
+
+ @param trackNum: an int containing the track number, or None
+ """
+ self._firstTrackNum = trackNum
+
+ firstTrackNum = property(getFirstTrackNum, setFirstTrackNum,
+ doc="The number of the first track on this disc.")
+
+ def getLastTrackNum(self):
+ """Returns the number of the last track on this disc.
+
+ @return: an int containing the track number, or None
+ """
+ return self._lastTrackNum
+
+ def setLastTrackNum(self, trackNum):
+ """Sets the number of the last track on this disc.
+
+ @param trackNum: an int containing the track number, or None
+ """
+ self._lastTrackNum = trackNum
+
+ lastTrackNum = property(getLastTrackNum, setLastTrackNum,
+ doc="The number of the last track on this disc.")
+
+ def getTracks(self):
+ """Returns the sector offset and length of this disc.
+
+ This method returns a list of tuples containing the track
+ offset and length in sectors for all tracks on this disc.
+ The track offset is measured from the beginning of the disc,
+ the length is relative to the track's offset. Note that the
+ leadout track is I{not} included.
+
+ @return: a list of (offset, length) tuples (values are ints)
+ """
+ return self._tracks
+
+ tracks = property(getTracks,
+ doc='Sector offset and length of all tracks.')
+
+ def addTrack(self, track):
+ """Adds a track to the list.
+
+ This method adds an (offset, length) tuple to the list of
+ tracks. The leadout track must I{not} be added. The total
+ length of the disc can be set using L{setSectors}.
+
+ @param track: an (offset, length) tuple (values are ints)
+
+ @see: L{getTracks}
+ """
+ self._tracks.append(track)
+
+
+class AbstractAlias(object):
+ """An abstract super class for all alias classes."""
+ def __init__(self, value=None, type_=None, script=None):
+ """Constructor.
+
+ @param value: a string containing the alias
+ @param type_: a string containing an absolute URI
+ @param script: a string containing an ISO-15924 script code
+ """
+ self._value = value
+ self._type = type_
+ self._script = script
+
+ def getValue(self):
+ """Returns the alias.
+
+ @return: a string containing the alias
+ """
+ return self._value
+
+ def setValue(self, value):
+ """Sets the alias.
+
+ @param value: a string containing the alias
+ """
+ self._value = value
+
+ value = property(getValue, setValue, doc='The alias value.')
+
+ def getType(self):
+ """Returns the alias type.
+
+ @return: a string containing an absolute URI, or None
+ """
+ return self._type
+
+ def setType(self, type_):
+ """Sets the alias type.
+
+ @param type_: a string containing an absolute URI, or None
+ """
+ self._type = type_
+
+ type = property(getType, setType, doc='The alias type.')
+
+ def getScript(self):
+ """Returns the alias script.
+
+ @return: a string containing an ISO-15924 script code
+ """
+ return self._script
+
+ def setScript(self, script):
+ """Sets the alias script.
+
+ @param script: a string containing an ISO-15924 script code
+ """
+ self._script = script
+
+ script = property(getScript, setScript, doc='The alias script.')
+
+
+class ArtistAlias(AbstractAlias):
+ """Represents an artist alias.
+
+ An alias (the I{alias value}) is a different representation of an
+ artist's name. This may be a common misspelling or a transliteration
+ (the I{alias type}).
+
+ The I{alias script} is interesting mostly for transliterations and
+ indicates which script is used for the alias value. To represent the
+ script, ISO-15924 script codes like 'Latn', 'Cyrl', or 'Hebr' are used.
+ """
+ pass
+
+
+class LabelAlias(AbstractAlias):
+ """Represents a label alias.
+
+ An alias (the I{alias value}) is a different representation of a
+ label's name. This may be a common misspelling or a transliteration
+ (the I{alias type}).
+
+ The I{alias script} is interesting mostly for transliterations and
+ indicates which script is used for the alias value. To represent the
+ script, ISO-15924 script codes like 'Latn', 'Cyrl', or 'Hebr' are used.
+ """
+ pass
+
+
+class User(object):
+ """Represents a MusicBrainz user."""
+
+ def __init__(self):
+ """Constructor."""
+ self._name = None
+ self._types = [ ]
+ self._showNag = None
+
+ def getName(self):
+ """Returns the user name.
+
+ @return: a string containing the user name
+ """
+ return self._name
+
+ def setName(self, name):
+ """Sets the user name.
+
+ @param name: a string containing the user name
+ """
+ self._name = name
+
+ name = property(getName, setName, doc='The MusicBrainz user name.')
+
+ def getTypes(self):
+ """Returns the types of this user.
+
+ Most users' type list is empty. Currently, the following types
+ are defined:
+
+ - 'http://musicbrainz.org/ns/ext-1.0#AutoEditor'
+ - 'http://musicbrainz.org/ns/ext-1.0#RelationshipEditor'
+ - 'http://musicbrainz.org/ns/ext-1.0#Bot'
+ - 'http://musicbrainz.org/ns/ext-1.0#NotNaggable'
+
+ @return: a list of strings containing absolute URIs
+ """
+ return self._types
+
+ types = property(getTypes, doc="The user's types.")
+
+ def addType(self, type_):
+ """Add a type to the list of types.
+
+ @param type_: a string containing absolute URIs
+
+ @see: L{getTypes}
+ """
+ self._types.append(type_)
+
+ def getShowNag(self):
+ """Returns true if a nag screen should be displayed to the user.
+
+ @return: C{True}, C{False}, or None
+ """
+ return self._showNag
+
+ def setShowNag(self, value):
+ """Sets the value of the nag screen flag.
+
+ If set to C{True},
+
+ @param value: C{True} or C{False}
+
+ @see: L{getShowNag}
+ """
+ self._showNag = value
+
+ showNag = property(getShowNag, setShowNag,
+ doc='The value of the nag screen flag.')
+
+# EOF
diff --git a/lib/musicbrainz2/utils.py b/lib/musicbrainz2/utils.py
new file mode 100644
index 00000000..0eff7be8
--- /dev/null
+++ b/lib/musicbrainz2/utils.py
@@ -0,0 +1,204 @@
+"""Various utilities to simplify common tasks.
+
+This module contains helper functions to make common tasks easier.
+
+@author: Matthias Friedrich
+"""
+__revision__ = '$Id: utils.py 11853 2009-07-21 09:26:50Z luks $'
+
+import re
+import urlparse
+import os.path
+
+__all__ = [
+ 'extractUuid', 'extractFragment', 'extractEntityType',
+ 'getReleaseTypeName', 'getCountryName', 'getLanguageName',
+ 'getScriptName',
+]
+
+
+# A pattern to split the path part of an absolute MB URI.
+PATH_PATTERN = '^/(artist|release|track|label|release-group)/([^/]*)$'
+
+
+def extractUuid(uriStr, resType=None):
+ """Extract the UUID part from a MusicBrainz identifier.
+
+ This function takes a MusicBrainz ID (an absolute URI) as the input
+ and returns the UUID part of the URI, thus turning it into a relative
+ URI. If C{uriStr} is None or a relative URI, then it is returned
+ unchanged.
+
+ The C{resType} parameter can be used for error checking. Set it to
+ 'artist', 'release', or 'track' to make sure C{uriStr} is a
+ syntactically valid MusicBrainz identifier of the given resource
+ type. If it isn't, a C{ValueError} exception is raised.
+ This error checking only works if C{uriStr} is an absolute URI, of
+ course.
+
+ Example:
+
+ >>> from musicbrainz2.utils import extractUuid
+ >>> extractUuid('http://musicbrainz.org/artist/c0b2500e-0cef-4130-869d-732b23ed9df5', 'artist')
+ 'c0b2500e-0cef-4130-869d-732b23ed9df5'
+ >>>
+
+ @param uriStr: a string containing a MusicBrainz ID (an URI), or None
+ @param resType: a string containing a resource type
+
+ @return: a string containing a relative URI, or None
+
+ @raise ValueError: the given URI is no valid MusicBrainz ID
+ """
+ if uriStr is None:
+ return None
+
+ (scheme, netloc, path) = urlparse.urlparse(uriStr)[:3]
+
+ if scheme == '':
+ return uriStr # no URI, probably already the UUID
+
+ if scheme != 'http' or netloc != 'musicbrainz.org':
+ raise ValueError('%s is no MB ID.' % uriStr)
+
+ m = re.match(PATH_PATTERN, path)
+
+ if m:
+ if resType is None:
+ return m.group(2)
+ else:
+ if m.group(1) == resType:
+ return m.group(2)
+ else:
+ raise ValueError('expected "%s" Id' % resType)
+ else:
+ raise ValueError('%s is no valid MB ID.' % uriStr)
+
+
+def extractFragment(uriStr, uriPrefix=None):
+ """Extract the fragment part from a URI.
+
+ If C{uriStr} is None or no absolute URI, then it is returned unchanged.
+
+ The C{uriPrefix} parameter can be used for error checking. If C{uriStr}
+ is an absolute URI, then the function checks if it starts with
+ C{uriPrefix}. If it doesn't, a C{ValueError} exception is raised.
+
+ @param uriStr: a string containing an absolute URI
+ @param uriPrefix: a string containing an URI prefix
+
+ @return: a string containing the fragment, or None
+
+ @raise ValueError: the given URI doesn't start with C{uriPrefix}
+ """
+ if uriStr is None:
+ return None
+
+ (scheme, netloc, path, params, query, frag) = urlparse.urlparse(uriStr)
+ if scheme == '':
+ return uriStr # this is no URI
+
+ if uriPrefix is None or uriStr.startswith(uriPrefix):
+ return frag
+ else:
+ raise ValueError("prefix doesn't match URI %s" % uriStr)
+
+
+def extractEntityType(uriStr):
+ """Returns the entity type an entity URI is referring to.
+
+ @param uriStr: a string containing an absolute entity URI
+
+ @return: a string containing 'artist', 'release', 'track', or 'label'
+
+ @raise ValueError: if the given URI is no valid MusicBrainz ID
+ """
+ if uriStr is None:
+ raise ValueError('None is no valid entity URI')
+
+ (scheme, netloc, path) = urlparse.urlparse(uriStr)[:3]
+
+ if scheme == '':
+ raise ValueError('%s is no absolute MB ID.' % uriStr)
+
+ if scheme != 'http' or netloc != 'musicbrainz.org':
+ raise ValueError('%s is no MB ID.' % uriStr)
+
+ m = re.match(PATH_PATTERN, path)
+
+ if m:
+ return m.group(1)
+ else:
+ raise ValueError('%s is no valid MB ID.' % uriStr)
+
+
+def getReleaseTypeName(releaseType):
+ """Returns the name of a release type URI.
+
+ @param releaseType: a string containing a release type URI
+
+ @return: a string containing a printable name for the release type
+
+ @see: L{musicbrainz2.model.Release}
+ """
+ from musicbrainz2.data.releasetypenames import releaseTypeNames
+ return releaseTypeNames.get(releaseType)
+
+
+def getCountryName(id_):
+ """Returns a country's name based on an ISO-3166 country code.
+
+ The country table this function is based on has been modified for
+ MusicBrainz purposes by using the extension mechanism defined in
+ ISO-3166. All IDs are still valid ISO-3166 country codes, but some
+ IDs have been added to include historic countries and some of the
+ country names have been modified to make them better suited for
+ display purposes.
+
+ If the country ID is not found, None is returned. This may happen
+ for example, when new countries are added to the MusicBrainz web
+ service which aren't known to this library yet.
+
+ @param id_: a two-letter upper case string containing an ISO-3166 code
+
+ @return: a string containing the country's name, or None
+
+ @see: L{musicbrainz2.model}
+ """
+ from musicbrainz2.data.countrynames import countryNames
+ return countryNames.get(id_)
+
+
+def getLanguageName(id_):
+ """Returns a language name based on an ISO-639-2/T code.
+
+ This function uses a subset of the ISO-639-2/T code table to map
+ language IDs (terminologic, not bibliographic ones!) to names.
+
+ @param id_: a three-letter upper case string containing an ISO-639-2/T code
+
+ @return: a string containing the language's name, or None
+
+ @see: L{musicbrainz2.model}
+ """
+ from musicbrainz2.data.languagenames import languageNames
+ return languageNames.get(id_)
+
+
+def getScriptName(id_):
+ """Returns a script name based on an ISO-15924 code.
+
+ This function uses a subset of the ISO-15924 code table to map
+ script IDs to names.
+
+ @param id_: a four-letter string containing an ISO-15924 script code
+
+ @return: a string containing the script's name, or None
+
+ @see: L{musicbrainz2.model}
+ """
+ from musicbrainz2.data.scriptnames import scriptNames
+ return scriptNames.get(id_)
+
+
+# EOF
diff --git a/lib/musicbrainz2/webservice.py b/lib/musicbrainz2/webservice.py
new file mode 100644
index 00000000..c0b76868
--- /dev/null
+++ b/lib/musicbrainz2/webservice.py
@@ -0,0 +1,1519 @@
+"""Classes for interacting with the MusicBrainz XML web service.
+
+The L{WebService} class talks to a server implementing the MusicBrainz XML
+web service. It mainly handles URL generation and network I/O. Use this
+if maximum control is needed.
+
+The L{Query} class provides a convenient interface to the most commonly
+used features of the web service. By default it uses L{WebService} to
+retrieve data and the L{XML parser } to parse the
+responses. The results are object trees using the L{MusicBrainz domain
+model }.
+
+@author: Matthias Friedrich
+"""
+__revision__ = '$Id: webservice.py 12973 2011-04-29 11:49:31Z luks $'
+
+import re
+import urllib
+import urllib2
+import urlparse
+import logging
+import os.path
+from StringIO import StringIO
+import lib.musicbrainz2 as musicbrainz2
+from lib.musicbrainz2.model import Artist, Release, Track
+from lib.musicbrainz2.wsxml import MbXmlParser, ParseError
+import lib.musicbrainz2.utils as mbutils
+
+__all__ = [
+ 'WebServiceError', 'AuthenticationError', 'ConnectionError',
+ 'RequestError', 'ResourceNotFoundError', 'ResponseError',
+ 'IIncludes', 'ArtistIncludes', 'ReleaseIncludes', 'TrackIncludes',
+ 'LabelIncludes', 'ReleaseGroupIncludes',
+ 'IFilter', 'ArtistFilter', 'ReleaseFilter', 'TrackFilter',
+ 'UserFilter', 'LabelFilter', 'ReleaseGroupFilter',
+ 'IWebService', 'WebService', 'Query',
+]
+
+
+class IWebService(object):
+ """An interface all concrete web service classes have to implement.
+
+ All web service classes have to implement this and follow the
+ method specifications.
+ """
+
+ def get(self, entity, id_, include, filter, version):
+ """Query the web service.
+
+ Using this method, you can either get a resource by id (using
+ the C{id_} parameter, or perform a query on all resources of
+ a type.
+
+ The C{filter} and the C{id_} parameter exclude each other. If
+ you are using a filter, you may not set C{id_} and vice versa.
+
+ Returns a file-like object containing the result or raises a
+ L{WebServiceError} or one of its subclasses in case of an
+ error. Which one is used depends on the implementing class.
+
+ @param entity: a string containing the entity's name
+ @param id_: a string containing a UUID, or the empty string
+ @param include: a tuple containing values for the 'inc' parameter
+ @param filter: parameters, depending on the entity
+ @param version: a string containing the web service version to use
+
+ @return: a file-like object
+
+ @raise WebServiceError: in case of errors
+ """
+ raise NotImplementedError()
+
+
+ def post(self, entity, id_, data, version):
+ """Submit data to the web service.
+
+ @param entity: a string containing the entity's name
+ @param id_: a string containing a UUID, or the empty string
+ @param data: A string containing the data to post
+ @param version: a string containing the web service version to use
+
+ @return: a file-like object
+
+ @raise WebServiceError: in case of errors
+ """
+ raise NotImplementedError()
+
+
+class WebServiceError(Exception):
+ """A web service error has occurred.
+
+ This is the base class for several other web service related
+ exceptions.
+ """
+
+ def __init__(self, msg='Webservice Error', reason=None):
+ """Constructor.
+
+ Set C{msg} to an error message which explains why this
+ exception was raised. The C{reason} parameter should be the
+ original exception which caused this L{WebService} exception
+ to be raised. If given, it has to be an instance of
+ C{Exception} or one of its child classes.
+
+ @param msg: a string containing an error message
+ @param reason: another exception instance, or None
+ """
+ Exception.__init__(self)
+ self.msg = msg
+ self.reason = reason
+
+ def __str__(self):
+ """Makes this class printable.
+
+ @return: a string containing an error message
+ """
+ return self.msg
+
+
+class ConnectionError(WebServiceError):
+ """Getting a server connection failed.
+
+ This exception is mostly used if the client couldn't connect to
+ the server because of an invalid host name or port. It doesn't
+ make sense if the web service in question doesn't use the network.
+ """
+ pass
+
+
+class RequestError(WebServiceError):
+ """An invalid request was made.
+
+ This exception is raised if the client made an invalid request.
+ That could be syntactically invalid identifiers or unknown or
+ invalid parameter values.
+ """
+ pass
+
+
+class ResourceNotFoundError(WebServiceError):
+ """No resource with the given ID exists.
+
+ This is usually a wrapper around IOError (which is superclass of
+ HTTPError).
+ """
+ pass
+
+
+class AuthenticationError(WebServiceError):
+ """Authentication failed.
+
+ This is thrown if user name, password or realm were invalid while
+ trying to access a protected resource.
+ """
+ pass
+
+
+class ResponseError(WebServiceError):
+ """The returned resource was invalid.
+
+ This may be due to a malformed XML document or if the requested
+ data wasn't part of the response. It can only occur in case of
+ bugs in the web service itself.
+ """
+ pass
+
+class DigestAuthHandler(urllib2.HTTPDigestAuthHandler):
+ """Patched DigestAuthHandler to correctly handle Digest Auth according to RFC 2617.
+
+ This will allow multiple qop values in the WWW-Authenticate header (e.g. "auth,auth-int").
+ The only supported qop value is still auth, though.
+ See http://bugs.python.org/issue9714
+
+ @author Kuno Woudt
+ """
+ def get_authorization(self, req, chal):
+ qop = chal.get('qop')
+ if qop and ',' in qop and 'auth' in qop.split(','):
+ chal['qop'] = 'auth'
+
+ return urllib2.HTTPDigestAuthHandler.get_authorization(self, req, chal)
+
+class WebService(IWebService):
+ """An interface to the MusicBrainz XML web service via HTTP.
+
+ By default, this class uses the MusicBrainz server but may be
+ configured for accessing other servers as well using the
+ L{constructor <__init__>}. This implements L{IWebService}, so
+ additional documentation on method parameters can be found there.
+ """
+
+ def __init__(self, host='musicbrainz.org', port=80, pathPrefix='/ws',
+ username=None, password=None, realm='musicbrainz.org',
+ opener=None):
+ """Constructor.
+
+ This can be used without parameters. In this case, the
+ MusicBrainz server will be used.
+
+ @param host: a string containing a host name
+ @param port: an integer containing a port number
+ @param pathPrefix: a string prepended to all URLs
+ @param username: a string containing a MusicBrainz user name
+ @param password: a string containing the user's password
+ @param realm: a string containing the realm used for authentication
+ @param opener: an C{urllib2.OpenerDirector} object used for queries
+ """
+ self._host = host
+ self._port = port
+ self._username = username
+ self._password = password
+ self._realm = realm
+ self._pathPrefix = pathPrefix
+ self._log = logging.getLogger(str(self.__class__))
+
+ if opener is None:
+ self._opener = urllib2.build_opener()
+ else:
+ self._opener = opener
+
+ passwordMgr = self._RedirectPasswordMgr()
+ authHandler = DigestAuthHandler(passwordMgr)
+ authHandler.add_password(self._realm, (), # no host set
+ self._username, self._password)
+ self._opener.add_handler(authHandler)
+
+
+ def _makeUrl(self, entity, id_, include=( ), filter={ },
+ version='1', type_='xml'):
+ params = dict(filter)
+ if type_ is not None:
+ params['type'] = type_
+ if len(include) > 0:
+ params['inc'] = ' '.join(include)
+
+ netloc = self._host
+ if self._port != 80:
+ netloc += ':' + str(self._port)
+ path = '/'.join((self._pathPrefix, version, entity, id_))
+
+ query = urllib.urlencode(params)
+
+ url = urlparse.urlunparse(('http', netloc, path, '', query,''))
+
+ return url
+
+
+ def _openUrl(self, url, data=None):
+ userAgent = 'python-musicbrainz/' + musicbrainz2.__version__
+ req = urllib2.Request(url)
+ req.add_header('User-Agent', userAgent)
+ return self._opener.open(req, data)
+
+
+ def get(self, entity, id_, include=( ), filter={ }, version='1'):
+ """Query the web service via HTTP-GET.
+
+ Returns a file-like object containing the result or raises a
+ L{WebServiceError}. Conditions leading to errors may be
+ invalid entities, IDs, C{include} or C{filter} parameters
+ and unsupported version numbers.
+
+ @raise ConnectionError: couldn't connect to server
+ @raise RequestError: invalid IDs or parameters
+ @raise AuthenticationError: invalid user name and/or password
+ @raise ResourceNotFoundError: resource doesn't exist
+
+ @see: L{IWebService.get}
+ """
+ url = self._makeUrl(entity, id_, include, filter, version)
+
+ self._log.debug('GET ' + url)
+
+ try:
+ return self._openUrl(url)
+ except urllib2.HTTPError, e:
+ self._log.debug("GET failed: " + str(e))
+ if e.code == 400: # in python 2.4: httplib.BAD_REQUEST
+ raise RequestError(str(e), e)
+ elif e.code == 401: # httplib.UNAUTHORIZED
+ raise AuthenticationError(str(e), e)
+ elif e.code == 404: # httplib.NOT_FOUND
+ raise ResourceNotFoundError(str(e), e)
+ else:
+ raise WebServiceError(str(e), e)
+ except urllib2.URLError, e:
+ self._log.debug("GET failed: " + str(e))
+ raise ConnectionError(str(e), e)
+
+
+ def post(self, entity, id_, data, version='1'):
+ """Send data to the web service via HTTP-POST.
+
+ Note that this may require authentication. You can set
+ user name, password and realm in the L{constructor <__init__>}.
+
+ @raise ConnectionError: couldn't connect to server
+ @raise RequestError: invalid IDs or parameters
+ @raise AuthenticationError: invalid user name and/or password
+ @raise ResourceNotFoundError: resource doesn't exist
+
+ @see: L{IWebService.post}
+ """
+ url = self._makeUrl(entity, id_, version=version, type_=None)
+
+ self._log.debug('POST ' + url)
+ self._log.debug('POST-BODY: ' + data)
+
+ try:
+ return self._openUrl(url, data)
+ except urllib2.HTTPError, e:
+ self._log.debug("POST failed: " + str(e))
+ if e.code == 400: # in python 2.4: httplib.BAD_REQUEST
+ raise RequestError(str(e), e)
+ elif e.code == 401: # httplib.UNAUTHORIZED
+ raise AuthenticationError(str(e), e)
+ elif e.code == 404: # httplib.NOT_FOUND
+ raise ResourceNotFoundError(str(e), e)
+ else:
+ raise WebServiceError(str(e), e)
+ except urllib2.URLError, e:
+ self._log.debug("POST failed: " + str(e))
+ raise ConnectionError(str(e), e)
+
+
+ # Special password manager which also works with redirects by simply
+ # ignoring the URI. As a consequence, only *ONE* (username, password)
+ # tuple per realm can be used for all URIs.
+ #
+ class _RedirectPasswordMgr(urllib2.HTTPPasswordMgr):
+ def __init__(self):
+ self._realms = { }
+
+ def find_user_password(self, realm, uri):
+ # ignoring the uri parameter intentionally
+ try:
+ return self._realms[realm]
+ except KeyError:
+ return (None, None)
+
+ def add_password(self, realm, uri, username, password):
+ # ignoring the uri parameter intentionally
+ self._realms[realm] = (username, password)
+
+
+class IFilter(object):
+ """A filter for collections.
+
+ This is the interface all filters have to implement. Filter classes
+ are initialized with a set of criteria and are then applied to
+ collections of items. The criteria are usually strings or integer
+ values, depending on the filter.
+
+ Note that all strings passed to filters should be unicode strings
+ (python type C{unicode}). Standard strings are converted to unicode
+ internally, but have a limitation: Only 7 Bit pure ASCII characters
+ may be used, otherwise a C{UnicodeDecodeError} is raised.
+ """
+ def createParameters(self):
+ """Create a list of query parameters.
+
+ This method creates a list of (C{parameter}, C{value}) tuples,
+ based on the contents of the implementing subclass.
+ C{parameter} is a string containing a parameter name
+ and C{value} an arbitrary string. No escaping of those strings
+ is required.
+
+ @return: a sequence of (key, value) pairs
+ """
+ raise NotImplementedError()
+
+
+class ArtistFilter(IFilter):
+ """A filter for the artist collection."""
+
+ def __init__(self, name=None, limit=None, offset=None, query=None):
+ """Constructor.
+
+ The C{query} parameter may contain a query in U{Lucene syntax
+ }.
+ Note that the C{name} and C{query} may not be used together.
+
+ @param name: a unicode string containing the artist's name
+ @param limit: the maximum number of artists to return
+ @param offset: start results at this zero-based offset
+ @param query: a string containing a query in Lucene syntax
+ """
+ self._params = [
+ ('name', name),
+ ('limit', limit),
+ ('offset', offset),
+ ('query', query),
+ ]
+
+ if not _paramsValid(self._params):
+ raise ValueError('invalid combination of parameters')
+
+ def createParameters(self):
+ return _createParameters(self._params)
+
+
+class LabelFilter(IFilter):
+ """A filter for the label collection."""
+
+ def __init__(self, name=None, limit=None, offset=None, query=None):
+ """Constructor.
+
+ The C{query} parameter may contain a query in U{Lucene syntax
+ }.
+ Note that the C{name} and C{query} may not be used together.
+
+ @param name: a unicode string containing the label's name
+ @param limit: the maximum number of labels to return
+ @param offset: start results at this zero-based offset
+ @param query: a string containing a query in Lucene syntax
+ """
+ self._params = [
+ ('name', name),
+ ('limit', limit),
+ ('offset', offset),
+ ('query', query),
+ ]
+
+ if not _paramsValid(self._params):
+ raise ValueError('invalid combination of parameters')
+
+ def createParameters(self):
+ return _createParameters(self._params)
+
+class ReleaseGroupFilter(IFilter):
+ """A filter for the release group collection."""
+
+ def __init__(self, title=None, releaseTypes=None, artistName=None,
+ artistId=None, limit=None, offset=None, query=None):
+ """Constructor.
+
+ If C{artistId} is set, only releases matching those IDs are
+ returned. The C{releaseTypes} parameter allows you to limit
+ the types of the release groups returned. You can set it to
+ C{(Release.TYPE_ALBUM, Release.TYPE_OFFICIAL)}, for example,
+ to only get officially released albums. Note that those values
+ are connected using the I{AND} operator. MusicBrainz' support
+ is currently very limited, so C{Release.TYPE_LIVE} and
+ C{Release.TYPE_COMPILATION} exclude each other (see U{the
+ documentation on release attributes
+ } for more
+ information and all valid values).
+
+ If both the C{artistName} and the C{artistId} parameter are
+ given, the server will ignore C{artistName}.
+
+ The C{query} parameter may contain a query in U{Lucene syntax
+ }.
+ Note that C{query} may not be used together with the other
+ parameters except for C{limit} and C{offset}.
+
+ @param title: a unicode string containing the release group's title
+ @param releaseTypes: a sequence of release type URIs
+ @param artistName: a unicode string containing the artist's name
+ @param artistId: a unicode string containing the artist's ID
+ @param limit: the maximum number of release groups to return
+ @param offset: start results at this zero-based offset
+ @param query: a string containing a query in Lucene syntax
+
+ @see: the constants in L{musicbrainz2.model.Release}
+ """
+ if releaseTypes is None or len(releaseTypes) == 0:
+ releaseTypesStr = None
+ else:
+ releaseTypesStr = ' '.join(map(mbutils.extractFragment, releaseTypes))
+
+ self._params = [
+ ('title', title),
+ ('releasetypes', releaseTypesStr),
+ ('artist', artistName),
+ ('artistid', mbutils.extractUuid(artistId)),
+ ('limit', limit),
+ ('offset', offset),
+ ('query', query),
+ ]
+
+ if not _paramsValid(self._params):
+ raise ValueError('invalid combination of parameters')
+
+ def createParameters(self):
+ return _createParameters(self._params)
+
+
+class ReleaseFilter(IFilter):
+ """A filter for the release collection."""
+
+ def __init__(self, title=None, discId=None, releaseTypes=None,
+ artistName=None, artistId=None, limit=None,
+ offset=None, query=None, trackCount=None):
+ """Constructor.
+
+ If C{discId} or C{artistId} are set, only releases matching
+ those IDs are returned. The C{releaseTypes} parameter allows
+ to limit the types of the releases returned. You can set it to
+ C{(Release.TYPE_ALBUM, Release.TYPE_OFFICIAL)}, for example,
+ to only get officially released albums. Note that those values
+ are connected using the I{AND} operator. MusicBrainz' support
+ is currently very limited, so C{Release.TYPE_LIVE} and
+ C{Release.TYPE_COMPILATION} exclude each other (see U{the
+ documentation on release attributes
+ } for more
+ information and all valid values).
+
+ If both the C{artistName} and the C{artistId} parameter are
+ given, the server will ignore C{artistName}.
+
+ The C{query} parameter may contain a query in U{Lucene syntax
+ }.
+ Note that C{query} may not be used together with the other
+ parameters except for C{limit} and C{offset}.
+
+ @param title: a unicode string containing the release's title
+ @param discId: a unicode string containing the DiscID
+ @param releaseTypes: a sequence of release type URIs
+ @param artistName: a unicode string containing the artist's name
+ @param artistId: a unicode string containing the artist's ID
+ @param limit: the maximum number of releases to return
+ @param offset: start results at this zero-based offset
+ @param query: a string containing a query in Lucene syntax
+ @param trackCount: the number of tracks in the release
+
+ @see: the constants in L{musicbrainz2.model.Release}
+ """
+ if releaseTypes is None or len(releaseTypes) == 0:
+ releaseTypesStr = None
+ else:
+ tmp = [ mbutils.extractFragment(x) for x in releaseTypes ]
+ releaseTypesStr = ' '.join(tmp)
+
+ self._params = [
+ ('title', title),
+ ('discid', discId),
+ ('releasetypes', releaseTypesStr),
+ ('artist', artistName),
+ ('artistid', mbutils.extractUuid(artistId)),
+ ('limit', limit),
+ ('offset', offset),
+ ('query', query),
+ ('count', trackCount),
+ ]
+
+ if not _paramsValid(self._params):
+ raise ValueError('invalid combination of parameters')
+
+ def createParameters(self):
+ return _createParameters(self._params)
+
+
+class TrackFilter(IFilter):
+ """A filter for the track collection."""
+
+ def __init__(self, title=None, artistName=None, artistId=None,
+ releaseTitle=None, releaseId=None,
+ duration=None, puid=None, limit=None, offset=None,
+ query=None):
+ """Constructor.
+
+ If C{artistId}, C{releaseId} or C{puid} are set, only tracks
+ matching those IDs are returned.
+
+ The server will ignore C{artistName} and C{releaseTitle} if
+ C{artistId} or ${releaseId} are set respectively.
+
+ The C{query} parameter may contain a query in U{Lucene syntax
+ }.
+ Note that C{query} may not be used together with the other
+ parameters except for C{limit} and C{offset}.
+
+ @param title: a unicode string containing the track's title
+ @param artistName: a unicode string containing the artist's name
+ @param artistId: a string containing the artist's ID
+ @param releaseTitle: a unicode string containing the release's title
+ @param releaseId: a string containing the release's title
+ @param duration: the track's length in milliseconds
+ @param puid: a string containing a PUID
+ @param limit: the maximum number of releases to return
+ @param offset: start results at this zero-based offset
+ @param query: a string containing a query in Lucene syntax
+ """
+ self._params = [
+ ('title', title),
+ ('artist', artistName),
+ ('artistid', mbutils.extractUuid(artistId)),
+ ('release', releaseTitle),
+ ('releaseid', mbutils.extractUuid(releaseId)),
+ ('duration', duration),
+ ('puid', puid),
+ ('limit', limit),
+ ('offset', offset),
+ ('query', query),
+ ]
+
+ if not _paramsValid(self._params):
+ raise ValueError('invalid combination of parameters')
+
+ def createParameters(self):
+ return _createParameters(self._params)
+
+
+class UserFilter(IFilter):
+ """A filter for the user collection."""
+
+ def __init__(self, name=None):
+ """Constructor.
+
+ @param name: a unicode string containing a MusicBrainz user name
+ """
+ self._name = name
+
+ def createParameters(self):
+ if self._name is not None:
+ return [ ('name', self._name.encode('utf-8')) ]
+ else:
+ return [ ]
+
+
+class IIncludes(object):
+ """An interface implemented by include tag generators."""
+ def createIncludeTags(self):
+ raise NotImplementedError()
+
+
+class ArtistIncludes(IIncludes):
+ """A specification on how much data to return with an artist.
+
+ Example:
+
+ >>> from musicbrainz2.model import Release
+ >>> from musicbrainz2.webservice import ArtistIncludes
+ >>> inc = ArtistIncludes(artistRelations=True, releaseRelations=True,
+ ... releases=(Release.TYPE_ALBUM, Release.TYPE_OFFICIAL))
+ >>>
+
+ The MusicBrainz server only supports some combinations of release
+ types for the C{releases} and C{vaReleases} include tags. At the
+ moment, not more than two release types should be selected, while
+ one of them has to be C{Release.TYPE_OFFICIAL},
+ C{Release.TYPE_PROMOTION} or C{Release.TYPE_BOOTLEG}.
+
+ @note: Only one of C{releases} and C{vaReleases} may be given.
+ """
+ def __init__(self, aliases=False, releases=(), vaReleases=(),
+ artistRelations=False, releaseRelations=False,
+ trackRelations=False, urlRelations=False, tags=False,
+ ratings=False, releaseGroups=False):
+
+ assert not isinstance(releases, basestring)
+ assert not isinstance(vaReleases, basestring)
+ assert len(releases) == 0 or len(vaReleases) == 0
+
+ self._includes = {
+ 'aliases': aliases,
+ 'artist-rels': artistRelations,
+ 'release-groups': releaseGroups,
+ 'release-rels': releaseRelations,
+ 'track-rels': trackRelations,
+ 'url-rels': urlRelations,
+ 'tags': tags,
+ 'ratings': ratings,
+ }
+
+ for elem in releases:
+ self._includes['sa-' + mbutils.extractFragment(elem)] = True
+
+ for elem in vaReleases:
+ self._includes['va-' + mbutils.extractFragment(elem)] = True
+
+ def createIncludeTags(self):
+ return _createIncludes(self._includes)
+
+
+class ReleaseIncludes(IIncludes):
+ """A specification on how much data to return with a release."""
+ def __init__(self, artist=False, counts=False, releaseEvents=False,
+ discs=False, tracks=False,
+ artistRelations=False, releaseRelations=False,
+ trackRelations=False, urlRelations=False,
+ labels=False, tags=False, ratings=False, isrcs=False,
+ releaseGroup=False):
+ self._includes = {
+ 'artist': artist,
+ 'counts': counts,
+ 'labels': labels,
+ 'release-groups': releaseGroup,
+ 'release-events': releaseEvents,
+ 'discs': discs,
+ 'tracks': tracks,
+ 'artist-rels': artistRelations,
+ 'release-rels': releaseRelations,
+ 'track-rels': trackRelations,
+ 'url-rels': urlRelations,
+ 'tags': tags,
+ 'ratings': ratings,
+ 'isrcs': isrcs,
+ }
+
+ # Requesting labels without releaseEvents makes no sense,
+ # so we pull in releaseEvents, if necessary.
+ if labels and not releaseEvents:
+ self._includes['release-events'] = True
+ # Ditto for isrcs with no tracks
+ if isrcs and not tracks:
+ self._includes['tracks'] = True
+
+ def createIncludeTags(self):
+ return _createIncludes(self._includes)
+
+
+class ReleaseGroupIncludes(IIncludes):
+ """A specification on how much data to return with a release group."""
+
+ def __init__(self, artist=False, releases=False, tags=False):
+ """Constructor.
+
+ @param artist: Whether to include the release group's main artist info.
+ @param releases: Whether to include the release group's releases.
+ """
+ self._includes = {
+ 'artist': artist,
+ 'releases': releases,
+ }
+
+ def createIncludeTags(self):
+ return _createIncludes(self._includes)
+
+
+class TrackIncludes(IIncludes):
+ """A specification on how much data to return with a track."""
+ def __init__(self, artist=False, releases=False, puids=False,
+ artistRelations=False, releaseRelations=False,
+ trackRelations=False, urlRelations=False, tags=False,
+ ratings=False, isrcs=False):
+ self._includes = {
+ 'artist': artist,
+ 'releases': releases,
+ 'puids': puids,
+ 'artist-rels': artistRelations,
+ 'release-rels': releaseRelations,
+ 'track-rels': trackRelations,
+ 'url-rels': urlRelations,
+ 'tags': tags,
+ 'ratings': ratings,
+ 'isrcs': isrcs,
+ }
+
+ def createIncludeTags(self):
+ return _createIncludes(self._includes)
+
+
+class LabelIncludes(IIncludes):
+ """A specification on how much data to return with a label."""
+ def __init__(self, aliases=False, tags=False, ratings=False):
+ self._includes = {
+ 'aliases': aliases,
+ 'tags': tags,
+ 'ratings': ratings,
+ }
+
+ def createIncludeTags(self):
+ return _createIncludes(self._includes)
+
+
+class Query(object):
+ """A simple interface to the MusicBrainz web service.
+
+ This is a facade which provides a simple interface to the MusicBrainz
+ web service. It hides all the details like fetching data from a server,
+ parsing the XML and creating an object tree. Using this class, you can
+ request data by ID or search the I{collection} of all resources
+ (artists, releases, or tracks) to retrieve those matching given
+ criteria. This document contains examples to get you started.
+
+
+ Working with Identifiers
+ ========================
+
+ MusicBrainz uses absolute URIs as identifiers. For example, the artist
+ 'Tori Amos' is identified using the following URI::
+ http://musicbrainz.org/artist/c0b2500e-0cef-4130-869d-732b23ed9df5
+
+ In some situations it is obvious from the context what type of
+ resource an ID refers to. In these cases, abbreviated identifiers may
+ be used, which are just the I{UUID} part of the URI. Thus the ID above
+ may also be written like this::
+ c0b2500e-0cef-4130-869d-732b23ed9df5
+
+ All methods in this class which require IDs accept both the absolute
+ URI and the abbreviated form (aka the relative URI).
+
+
+ Creating a Query Object
+ =======================
+
+ In most cases, creating a L{Query} object is as simple as this:
+
+ >>> import musicbrainz2.webservice as ws
+ >>> q = ws.Query()
+ >>>
+
+ The instantiated object uses the standard L{WebService} class to
+ access the MusicBrainz web service. If you want to use a different
+ server or you have to pass user name and password because one of
+ your queries requires authentication, you have to create the
+ L{WebService} object yourself and configure it appropriately.
+ This example uses the MusicBrainz test server and also sets
+ authentication data:
+
+ >>> import musicbrainz2.webservice as ws
+ >>> service = ws.WebService(host='test.musicbrainz.org',
+ ... username='whatever', password='secret')
+ >>> q = ws.Query(service)
+ >>>
+
+
+ Querying for Individual Resources
+ =================================
+
+ If the MusicBrainz ID of a resource is known, then the L{getArtistById},
+ L{getReleaseById}, or L{getTrackById} method can be used to retrieve
+ it. Example:
+
+ >>> import musicbrainz2.webservice as ws
+ >>> q = ws.Query()
+ >>> artist = q.getArtistById('c0b2500e-0cef-4130-869d-732b23ed9df5')
+ >>> artist.name
+ u'Tori Amos'
+ >>> artist.sortName
+ u'Amos, Tori'
+ >>> print artist.type
+ http://musicbrainz.org/ns/mmd-1.0#Person
+ >>>
+
+ This returned just the basic artist data, however. To get more detail
+ about a resource, the C{include} parameters may be used which expect
+ an L{ArtistIncludes}, L{ReleaseIncludes}, or L{TrackIncludes} object,
+ depending on the resource type.
+
+ To get data about a release which also includes the main artist
+ and all tracks, for example, the following query can be used:
+
+ >>> import musicbrainz2.webservice as ws
+ >>> q = ws.Query()
+ >>> releaseId = '33dbcf02-25b9-4a35-bdb7-729455f33ad7'
+ >>> include = ws.ReleaseIncludes(artist=True, tracks=True)
+ >>> release = q.getReleaseById(releaseId, include)
+ >>> release.title
+ u'Tales of a Librarian'
+ >>> release.artist.name
+ u'Tori Amos'
+ >>> release.tracks[0].title
+ u'Precious Things'
+ >>>
+
+ Note that the query gets more expensive for the server the more
+ data you request, so please be nice.
+
+
+ Searching in Collections
+ ========================
+
+ For each resource type (artist, release, and track), there is one
+ collection which contains all resources of a type. You can search
+ these collections using the L{getArtists}, L{getReleases}, and
+ L{getTracks} methods. The collections are huge, so you have to
+ use filters (L{ArtistFilter}, L{ReleaseFilter}, or L{TrackFilter})
+ to retrieve only resources matching given criteria.
+
+ For example, If you want to search the release collection for
+ releases with a specified DiscID, you would use L{getReleases}
+ and a L{ReleaseFilter} object:
+
+ >>> import musicbrainz2.webservice as ws
+ >>> q = ws.Query()
+ >>> filter = ws.ReleaseFilter(discId='8jJklE258v6GofIqDIrE.c5ejBE-')
+ >>> results = q.getReleases(filter=filter)
+ >>> results[0].score
+ 100
+ >>> results[0].release.title
+ u'Under the Pink'
+ >>>
+
+ The query returns a list of results (L{wsxml.ReleaseResult} objects
+ in this case), which are ordered by score, with a higher score
+ indicating a better match. Note that those results don't contain
+ all the data about a resource. If you need more detail, you can then
+ use the L{getArtistById}, L{getReleaseById}, or L{getTrackById}
+ methods to request the resource.
+
+ All filters support the C{limit} argument to limit the number of
+ results returned. This defaults to 25, but the server won't send
+ more than 100 results to save bandwidth and processing power. Using
+ C{limit} and the C{offset} parameter, you can page through the
+ results.
+
+
+ Error Handling
+ ==============
+
+ All methods in this class raise a L{WebServiceError} exception in case
+ of errors. Depending on the method, a subclass of L{WebServiceError} may
+ be raised which allows an application to handle errors more precisely.
+ The following example handles connection errors (invalid host name
+ etc.) separately and all other web service errors in a combined
+ catch clause:
+
+ >>> try:
+ ... artist = q.getArtistById('c0b2500e-0cef-4130-869d-732b23ed9df5')
+ ... except ws.ConnectionError, e:
+ ... pass # implement your error handling here
+ ... except ws.WebServiceError, e:
+ ... pass # catches all other web service errors
+ ...
+ >>>
+ """
+
+ def __init__(self, ws=None, wsFactory=WebService, clientId=None):
+ """Constructor.
+
+ The C{ws} parameter has to be a subclass of L{IWebService}.
+ If it isn't given, the C{wsFactory} parameter is used to
+ create an L{IWebService} subclass.
+
+ If the constructor is called without arguments, an instance
+ of L{WebService} is used, preconfigured to use the MusicBrainz
+ server. This should be enough for most users.
+
+ If you want to use queries which require authentication you
+ have to pass a L{WebService} instance where user name and
+ password have been set.
+
+ The C{clientId} parameter is required for data submission.
+ The format is C{'application-version'}, where C{application}
+ is your application's name and C{version} is a version
+ number which may not include a '-' character.
+
+ @param ws: a subclass instance of L{IWebService}, or None
+ @param wsFactory: a callable object which creates an object
+ @param clientId: a unicode string containing the application's ID
+ """
+ if ws is None:
+ self._ws = wsFactory()
+ else:
+ self._ws = ws
+
+ self._clientId = clientId
+ self._log = logging.getLogger(str(self.__class__))
+
+
+ def getArtistById(self, id_, include=None):
+ """Returns an artist.
+
+ If no artist with that ID can be found, C{include} contains
+ invalid tags or there's a server problem, an exception is
+ raised.
+
+ @param id_: a string containing the artist's ID
+ @param include: an L{ArtistIncludes} object, or None
+
+ @return: an L{Artist } object, or None
+
+ @raise ConnectionError: couldn't connect to server
+ @raise RequestError: invalid ID or include tags
+ @raise ResourceNotFoundError: artist doesn't exist
+ @raise ResponseError: server returned invalid data
+ """
+ uuid = mbutils.extractUuid(id_, 'artist')
+ result = self._getFromWebService('artist', uuid, include)
+ artist = result.getArtist()
+ if artist is not None:
+ return artist
+ else:
+ raise ResponseError("server didn't return artist")
+
+
+ def getArtists(self, filter):
+ """Returns artists matching given criteria.
+
+ @param filter: an L{ArtistFilter} object
+
+ @return: a list of L{musicbrainz2.wsxml.ArtistResult} objects
+
+ @raise ConnectionError: couldn't connect to server
+ @raise RequestError: invalid ID or include tags
+ @raise ResponseError: server returned invalid data
+ """
+ result = self._getFromWebService('artist', '', filter=filter)
+ return result.getArtistResults()
+
+ def getLabelById(self, id_, include=None):
+ """Returns a L{model.Label}
+
+ If no label with that ID can be found, or there is a server problem,
+ an exception is raised.
+
+ @param id_: a string containing the label's ID.
+
+ @raise ConnectionError: couldn't connect to server
+ @raise RequestError: invalid ID or include tags
+ @raise ResourceNotFoundError: release doesn't exist
+ @raise ResponseError: server returned invalid data
+ """
+ uuid = mbutils.extractUuid(id_, 'label')
+ result = self._getFromWebService('label', uuid, include)
+ label = result.getLabel()
+ if label is not None:
+ return label
+ else:
+ raise ResponseError("server didn't return a label")
+
+ def getLabels(self, filter):
+ result = self._getFromWebService('label', '', filter=filter)
+ return result.getLabelResults()
+
+ def getReleaseById(self, id_, include=None):
+ """Returns a release.
+
+ If no release with that ID can be found, C{include} contains
+ invalid tags or there's a server problem, and exception is
+ raised.
+
+ @param id_: a string containing the release's ID
+ @param include: a L{ReleaseIncludes} object, or None
+
+ @return: a L{Release } object, or None
+
+ @raise ConnectionError: couldn't connect to server
+ @raise RequestError: invalid ID or include tags
+ @raise ResourceNotFoundError: release doesn't exist
+ @raise ResponseError: server returned invalid data
+ """
+ uuid = mbutils.extractUuid(id_, 'release')
+ result = self._getFromWebService('release', uuid, include)
+ release = result.getRelease()
+ if release is not None:
+ return release
+ else:
+ raise ResponseError("server didn't return release")
+
+
+ def getReleases(self, filter):
+ """Returns releases matching given criteria.
+
+ @param filter: a L{ReleaseFilter} object
+
+ @return: a list of L{musicbrainz2.wsxml.ReleaseResult} objects
+
+ @raise ConnectionError: couldn't connect to server
+ @raise RequestError: invalid ID or include tags
+ @raise ResponseError: server returned invalid data
+ """
+ result = self._getFromWebService('release', '', filter=filter)
+ return result.getReleaseResults()
+
+ def getReleaseGroupById(self, id_, include=None):
+ """Returns a release group.
+
+ If no release group with that ID can be found, C{include}
+ contains invalid tags, or there's a server problem, an
+ exception is raised.
+
+ @param id_: a string containing the release group's ID
+ @param include: a L{ReleaseGroupIncludes} object, or None
+
+ @return: a L{ReleaseGroup } object, or None
+
+ @raise ConnectionError: couldn't connect to server
+ @raise RequestError: invalid ID or include tags
+ @raise ResourceNotFoundError: release doesn't exist
+ @raise ResponseError: server returned invalid data
+ """
+ uuid = mbutils.extractUuid(id_, 'release-group')
+ result = self._getFromWebService('release-group', uuid, include)
+ releaseGroup = result.getReleaseGroup()
+ if releaseGroup is not None:
+ return releaseGroup
+ else:
+ raise ResponseError("server didn't return releaseGroup")
+
+ def getReleaseGroups(self, filter):
+ """Returns release groups matching the given criteria.
+
+ @param filter: a L{ReleaseGroupFilter} object
+
+ @return: a list of L{musicbrainz2.wsxml.ReleaseGroupResult} objects
+
+ @raise ConnectionError: couldn't connect to server
+ @raise RequestError: invalid ID or include tags
+ @raise ResponseError: server returned invalid data
+ """
+ result = self._getFromWebService('release-group', '', filter=filter)
+ return result.getReleaseGroupResults()
+
+ def getTrackById(self, id_, include=None):
+ """Returns a track.
+
+ If no track with that ID can be found, C{include} contains
+ invalid tags or there's a server problem, an exception is
+ raised.
+
+ @param id_: a string containing the track's ID
+ @param include: a L{TrackIncludes} object, or None
+
+ @return: a L{Track } object, or None
+
+ @raise ConnectionError: couldn't connect to server
+ @raise RequestError: invalid ID or include tags
+ @raise ResourceNotFoundError: track doesn't exist
+ @raise ResponseError: server returned invalid data
+ """
+ uuid = mbutils.extractUuid(id_, 'track')
+ result = self._getFromWebService('track', uuid, include)
+ track = result.getTrack()
+ if track is not None:
+ return track
+ else:
+ raise ResponseError("server didn't return track")
+
+
+ def getTracks(self, filter):
+ """Returns tracks matching given criteria.
+
+ @param filter: a L{TrackFilter} object
+
+ @return: a list of L{musicbrainz2.wsxml.TrackResult} objects
+
+ @raise ConnectionError: couldn't connect to server
+ @raise RequestError: invalid ID or include tags
+ @raise ResponseError: server returned invalid data
+ """
+ result = self._getFromWebService('track', '', filter=filter)
+ return result.getTrackResults()
+
+
+ def getUserByName(self, name):
+ """Returns information about a MusicBrainz user.
+
+ You can only request user data if you know the user name and
+ password for that account. If username and/or password are
+ incorrect, an L{AuthenticationError} is raised.
+
+ See the example in L{Query} on how to supply user name and
+ password.
+
+ @param name: a unicode string containing the user's name
+
+ @return: a L{User } object
+
+ @raise ConnectionError: couldn't connect to server
+ @raise RequestError: invalid ID or include tags
+ @raise AuthenticationError: invalid user name and/or password
+ @raise ResourceNotFoundError: track doesn't exist
+ @raise ResponseError: server returned invalid data
+ """
+ filter = UserFilter(name=name)
+ result = self._getFromWebService('user', '', None, filter)
+
+ if len(result.getUserList()) > 0:
+ return result.getUserList()[0]
+ else:
+ raise ResponseError("response didn't contain user data")
+
+
+ def _getFromWebService(self, entity, id_, include=None, filter=None):
+ if filter is None:
+ filterParams = [ ]
+ else:
+ filterParams = filter.createParameters()
+
+ if include is None:
+ includeParams = [ ]
+ else:
+ includeParams = include.createIncludeTags()
+
+ stream = self._ws.get(entity, id_, includeParams, filterParams)
+ try:
+ parser = MbXmlParser()
+ return parser.parse(stream)
+ except ParseError, e:
+ raise ResponseError(str(e), e)
+
+
+ def submitPuids(self, tracks2puids):
+ """Submit track to PUID mappings.
+
+ The C{tracks2puids} parameter has to be a dictionary, with the
+ keys being MusicBrainz track IDs (either as absolute URIs or
+ in their 36 character ASCII representation) and the values
+ being PUIDs (ASCII, 36 characters).
+
+ Note that this method only works if a valid user name and
+ password have been set. See the example in L{Query} on how
+ to supply authentication data.
+
+ @param tracks2puids: a dictionary mapping track IDs to PUIDs
+
+ @raise ConnectionError: couldn't connect to server
+ @raise RequestError: invalid track or PUIDs
+ @raise AuthenticationError: invalid user name and/or password
+ """
+ assert self._clientId is not None, 'Please supply a client ID'
+ params = [ ]
+ params.append( ('client', self._clientId.encode('utf-8')) )
+
+ for (trackId, puid) in tracks2puids.iteritems():
+ trackId = mbutils.extractUuid(trackId, 'track')
+ params.append( ('puid', trackId + ' ' + puid) )
+
+ encodedStr = urllib.urlencode(params, True)
+
+ self._ws.post('track', '', encodedStr)
+
+ def submitISRCs(self, tracks2isrcs):
+ """Submit track to ISRC mappings.
+
+ The C{tracks2isrcs} parameter has to be a dictionary, with the
+ keys being MusicBrainz track IDs (either as absolute URIs or
+ in their 36 character ASCII representation) and the values
+ being ISRCs (ASCII, 12 characters).
+
+ Note that this method only works if a valid user name and
+ password have been set. See the example in L{Query} on how
+ to supply authentication data.
+
+ @param tracks2isrcs: a dictionary mapping track IDs to ISRCs
+
+ @raise ConnectionError: couldn't connect to server
+ @raise RequestError: invalid track or ISRCs
+ @raise AuthenticationError: invalid user name and/or password
+ """
+ params = [ ]
+
+ for (trackId, isrc) in tracks2isrcs.iteritems():
+ trackId = mbutils.extractUuid(trackId, 'track')
+ params.append( ('isrc', trackId + ' ' + isrc) )
+
+ encodedStr = urllib.urlencode(params, True)
+
+ self._ws.post('track', '', encodedStr)
+
+ def addToUserCollection(self, releases):
+ """Add releases to a user's collection.
+
+ The releases parameter must be a list. It can contain either L{Release}
+ objects or a string representing a MusicBrainz release ID (either as
+ absolute URIs or in their 36 character ASCII representation).
+
+ Adding a release that is already in the collection has no effect.
+
+ @param releases: a list of releases to add to the user collection
+
+ @raise ConnectionError: couldn't connect to server
+ @raise AuthenticationError: invalid user name and/or password
+ """
+ rels = []
+ for release in releases:
+ if isinstance(release, Release):
+ rels.append(mbutils.extractUuid(release.id))
+ else:
+ rels.append(mbutils.extractUuid(release))
+ encodedStr = urllib.urlencode({'add': ",".join(rels)}, True)
+ self._ws.post('collection', '', encodedStr)
+
+ def removeFromUserCollection(self, releases):
+ """Remove releases from a user's collection.
+
+ The releases parameter must be a list. It can contain either L{Release}
+ objects or a string representing a MusicBrainz release ID (either as
+ absolute URIs or in their 36 character ASCII representation).
+
+ Removing a release that is not in the collection has no effect.
+
+ @param releases: a list of releases to remove from the user collection
+
+ @raise ConnectionError: couldn't connect to server
+ @raise AuthenticationError: invalid user name and/or password
+ """
+ rels = []
+ for release in releases:
+ if isinstance(release, Release):
+ rels.append(mbutils.extractUuid(release.id))
+ else:
+ rels.append(mbutils.extractUuid(release))
+ encodedStr = urllib.urlencode({'remove': ",".join(rels)}, True)
+ self._ws.post('collection', '', encodedStr)
+
+ def getUserCollection(self, offset=0, maxitems=100):
+ """Get the releases that are in a user's collection
+
+ A maximum of 100 items will be returned for any one call
+ to this method. To fetch more than 100 items, use the offset
+ parameter.
+
+ @param offset: the offset to start fetching results from
+ @param maxitems: the upper limit on items to return
+
+ @return: a list of L{musicbrainz2.wsxml.ReleaseResult} objects
+
+ @raise ConnectionError: couldn't connect to server
+ @raise AuthenticationError: invalid user name and/or password
+ """
+ params = { 'offset': offset, 'maxitems': maxitems }
+
+ stream = self._ws.get('collection', '', filter=params)
+ print stream
+ try:
+ parser = MbXmlParser()
+ result = parser.parse(stream)
+ except ParseError, e:
+ raise ResponseError(str(e), e)
+
+ return result.getReleaseResults()
+
+ def submitUserTags(self, entityUri, tags):
+ """Submit folksonomy tags for an entity.
+
+ Note that all previously existing tags from the authenticated
+ user are replaced with the ones given to this method. Other
+ users' tags are not affected.
+
+ @param entityUri: a string containing an absolute MB ID
+ @param tags: A list of either L{Tag } objects
+ or strings
+
+ @raise ValueError: invalid entityUri
+ @raise ConnectionError: couldn't connect to server
+ @raise RequestError: invalid ID, entity or tags
+ @raise AuthenticationError: invalid user name and/or password
+ """
+ entity = mbutils.extractEntityType(entityUri)
+ uuid = mbutils.extractUuid(entityUri, entity)
+ params = (
+ ('type', 'xml'),
+ ('entity', entity),
+ ('id', uuid),
+ ('tags', ','.join([unicode(tag).encode('utf-8') for tag in tags]))
+ )
+
+ encodedStr = urllib.urlencode(params)
+
+ self._ws.post('tag', '', encodedStr)
+
+
+ def getUserTags(self, entityUri):
+ """Returns a list of folksonomy tags a user has applied to an entity.
+
+ The given parameter has to be a fully qualified MusicBrainz ID, as
+ returned by other library functions.
+
+ Note that this method only works if a valid user name and
+ password have been set. Only the tags the authenticated user
+ applied to the entity will be returned. If username and/or
+ password are incorrect, an AuthenticationError is raised.
+
+ This method will return a list of L{Tag }
+ objects.
+
+ @param entityUri: a string containing an absolute MB ID
+
+ @raise ValueError: invalid entityUri
+ @raise ConnectionError: couldn't connect to server
+ @raise RequestError: invalid ID or entity
+ @raise AuthenticationError: invalid user name and/or password
+ """
+ entity = mbutils.extractEntityType(entityUri)
+ uuid = mbutils.extractUuid(entityUri, entity)
+ params = { 'entity': entity, 'id': uuid }
+
+ stream = self._ws.get('tag', '', filter=params)
+ try:
+ parser = MbXmlParser()
+ result = parser.parse(stream)
+ except ParseError, e:
+ raise ResponseError(str(e), e)
+
+ return result.getTagList()
+
+ def submitUserRating(self, entityUri, rating):
+ """Submit rating for an entity.
+
+ Note that all previously existing rating from the authenticated
+ user are replaced with the one given to this method. Other
+ users' ratings are not affected.
+
+ @param entityUri: a string containing an absolute MB ID
+ @param rating: A L{Rating } object
+ or integer
+
+ @raise ValueError: invalid entityUri
+ @raise ConnectionError: couldn't connect to server
+ @raise RequestError: invalid ID, entity or tags
+ @raise AuthenticationError: invalid user name and/or password
+ """
+ entity = mbutils.extractEntityType(entityUri)
+ uuid = mbutils.extractUuid(entityUri, entity)
+ params = (
+ ('type', 'xml'),
+ ('entity', entity),
+ ('id', uuid),
+ ('rating', unicode(rating).encode('utf-8'))
+ )
+
+ encodedStr = urllib.urlencode(params)
+
+ self._ws.post('rating', '', encodedStr)
+
+
+ def getUserRating(self, entityUri):
+ """Return the rating a user has applied to an entity.
+
+ The given parameter has to be a fully qualified MusicBrainz
+ ID, as returned by other library functions.
+
+ Note that this method only works if a valid user name and
+ password have been set. Only the rating the authenticated user
+ applied to the entity will be returned. If username and/or
+ password are incorrect, an AuthenticationError is raised.
+
+ This method will return a L{Rating }
+ object.
+
+ @param entityUri: a string containing an absolute MB ID
+
+ @raise ValueError: invalid entityUri
+ @raise ConnectionError: couldn't connect to server
+ @raise RequestError: invalid ID or entity
+ @raise AuthenticationError: invalid user name and/or password
+ """
+ entity = mbutils.extractEntityType(entityUri)
+ uuid = mbutils.extractUuid(entityUri, entity)
+ params = { 'entity': entity, 'id': uuid }
+
+ stream = self._ws.get('rating', '', filter=params)
+ try:
+ parser = MbXmlParser()
+ result = parser.parse(stream)
+ except ParseError, e:
+ raise ResponseError(str(e), e)
+
+ return result.getRating()
+
+ def submitCDStub(self, cdstub):
+ """Submit a CD Stub to the database.
+
+ The number of tracks added to the CD Stub must match the TOC and DiscID
+ otherwise the submission wil fail. The submission will also fail if
+ the Disc ID is already in the MusicBrainz database.
+
+ This method will only work if no user name and password are set.
+
+ @param cdstub: a L{CDStub} object to submit
+
+ @raise RequestError: Missmatching TOC/Track information or the
+ the CD Stub already exists or the Disc ID already exists
+ """
+ assert self._clientId is not None, 'Please supply a client ID'
+ disc = cdstub._disc
+ params = [ ]
+ params.append( ('client', self._clientId.encode('utf-8')) )
+ params.append( ('discid', disc.id) )
+ params.append( ('title', cdstub.title) )
+ params.append( ('artist', cdstub.artist) )
+ if cdstub.barcode != "":
+ params.append( ('barcode', cdstub.barcode) )
+ if cdstub.comment != "":
+ params.append( ('comment', cdstub.comment) )
+
+ trackind = 0
+ for track,artist in cdstub.tracks:
+ params.append( ('track%d' % trackind, track) )
+ if artist != "":
+ params.append( ('artist%d' % trackind, artist) )
+
+ trackind += 1
+
+ toc = "%d %d %d " % (disc.firstTrackNum, disc.lastTrackNum, disc.sectors)
+ toc = toc + ' '.join( map(lambda x: str(x[0]), disc.getTracks()) )
+
+ params.append( ('toc', toc) )
+
+ encodedStr = urllib.urlencode(params)
+ self._ws.post('release', '', encodedStr)
+
+def _createIncludes(tagMap):
+ selected = filter(lambda x: x[1] == True, tagMap.items())
+ return map(lambda x: x[0], selected)
+
+def _createParameters(params):
+ """Remove (x, None) tuples and encode (x, str/unicode) to utf-8."""
+ ret = [ ]
+ for p in params:
+ if isinstance(p[1], (str, unicode)):
+ ret.append( (p[0], p[1].encode('utf-8')) )
+ elif p[1] is not None:
+ ret.append(p)
+
+ return ret
+
+def _paramsValid(params):
+ """Check if the query parameter collides with other parameters."""
+ tmp = [ ]
+ for name, value in params:
+ if value is not None and name not in ('offset', 'limit'):
+ tmp.append(name)
+
+ if 'query' in tmp and len(tmp) > 1:
+ return False
+ else:
+ return True
+
+if __name__ == '__main__':
+ import doctest
+ doctest.testmod()
+
+# EOF
diff --git a/lib/musicbrainz2/wsxml.py b/lib/musicbrainz2/wsxml.py
new file mode 100644
index 00000000..7d031ca5
--- /dev/null
+++ b/lib/musicbrainz2/wsxml.py
@@ -0,0 +1,1675 @@
+"""A parser for the Music Metadata XML Format (MMD).
+
+This module contains L{MbXmlParser}, which parses the U{Music Metadata XML
+Format (MMD) (.*?) ',line).group(0)
+ key = re.sub("","",rawkey)
+ restOfLine = re.sub(".*? ","",line).strip()
+ return key,restOfLine
+
+ def parser(self,lines):
+ dicts = 0
+ songs = {}
+ inSong = False
+ for line in lines:
+ if re.search('',line):
+ dicts += 1
+ if re.search(' ',line):
+ dicts -= 1
+ inSong = False
+ songs[songkey] = temp
+ if dicts == 2 and re.search('(.*?) ',line):
+ rawkey = re.search('(.*?) ',line).group(0)
+ songkey = re.sub("","",rawkey)
+ inSong = True
+ temp = {}
+ if dicts == 3 and re.search('(.*?) ',line):
+ key,restOfLine = self.keyAndRestOfLine(line)
+ temp[key] = self.getValue(restOfLine)
+ if len(songs) > 0 and dicts < 2:
+ return songs
+ return songs
\ No newline at end of file
diff --git a/lib/pyItunes/__init__.py b/lib/pyItunes/__init__.py
new file mode 100644
index 00000000..eb66d826
--- /dev/null
+++ b/lib/pyItunes/__init__.py
@@ -0,0 +1,3 @@
+from lib.pyItunes.XMLLibraryParser import XMLLibraryParser
+from lib.pyItunes.Library import Library
+from lib.pyItunes.Song import Song
\ No newline at end of file
diff --git a/lib/pygithub/__init__.py b/lib/pygithub/__init__.py
new file mode 100644
index 00000000..ad56e087
--- /dev/null
+++ b/lib/pygithub/__init__.py
@@ -0,0 +1,25 @@
+# Copyright (c) 2005-2008 Dustin Sallings
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+#
+#
+"""
+github module.
+"""
+__all__ = ['github','ghsearch','githubsync']
diff --git a/lib/pygithub/ghsearch.py b/lib/pygithub/ghsearch.py
new file mode 100644
index 00000000..586e502b
--- /dev/null
+++ b/lib/pygithub/ghsearch.py
@@ -0,0 +1,50 @@
+#!/usr/bin/env python
+#
+# Copyright (c) 2005-2008 Dustin Sallings
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+#
+#
+"""
+Search script.
+"""
+
+import sys
+
+import github
+
+def usage():
+ """display the usage and exit"""
+ print "Usage: %s keyword [keyword...]" % (sys.argv[0])
+ sys.exit(1)
+
+def mk_url(repo):
+ return "http://github.com/%s/%s" % (repo.username, repo.name)
+
+if __name__ == '__main__':
+ g = github.GitHub()
+ if len(sys.argv) < 2:
+ usage()
+ res = g.repos.search(' '.join(sys.argv[1:]))
+
+ for repo in res:
+ try:
+ print "Found %s at %s" % (repo.name, mk_url(repo))
+ except AttributeError:
+ print "Bug: Couldn't format %s" % repo.__dict__
diff --git a/lib/pygithub/github.py b/lib/pygithub/github.py
new file mode 100644
index 00000000..bd9f4077
--- /dev/null
+++ b/lib/pygithub/github.py
@@ -0,0 +1,520 @@
+#!/usr/bin/env python
+#
+# Copyright (c) 2005-2008 Dustin Sallings
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+#
+#
+"""
+Interface to github's API (v2).
+
+Basic usage:
+
+g = GitHub()
+
+for r in g.user.search('dustin'):
+ print r.name
+
+See the GitHub docs or README.markdown for more usage.
+
+Copyright (c) 2007 Dustin Sallings
+"""
+
+# GAE friendly URL detection (theoretically)
+try:
+ import urllib2
+ default_fetcher = urllib2.urlopen
+except LoadError:
+ pass
+
+import urllib
+import xml
+import xml.dom.minidom
+
+def _string_parser(x):
+ """Extract the data from the first child of the input."""
+ return x.firstChild.data
+
+_types = {
+ 'string': _string_parser,
+ 'integer': lambda x: int(_string_parser(x)),
+ 'float': lambda x: float(_string_parser(x)),
+ 'datetime': _string_parser,
+ 'boolean': lambda x: _string_parser(x) == 'true'
+}
+
+def _parse(el):
+ """Generic response parser."""
+
+ type = 'string'
+ if el.attributes and 'type' in el.attributes.keys():
+ type = el.attributes['type'].value
+ elif el.localName in _types:
+ type = el.localName
+ elif len(el.childNodes) > 1:
+ # This is a container, find the child type
+ type = None
+ ch = el.firstChild
+ while ch and not type:
+ if ch.localName == 'type':
+ type = ch.firstChild.data
+ ch = ch.nextSibling
+
+ if not type:
+ raise Exception("Can't parse %s, known: %s"
+ % (el.toxml(), repr(_types.keys())))
+
+ return _types[type](el)
+
+def parses(t):
+ """Parser for a specific type in the github response."""
+ def f(orig):
+ orig.parses = t
+ return orig
+ return f
+
+def with_temporary_mappings(m):
+ """Allow temporary localized altering of type mappings."""
+ def f(orig):
+ def every(self, *args):
+ global _types
+ o = _types.copy()
+ for k,v in m.items():
+ if v:
+ _types[k] = v
+ else:
+ del _types[k]
+ try:
+ return orig(self, *args)
+ finally:
+ _types = o
+ return every
+ return f
+
+@parses('array')
+def _parseArray(el):
+ rv = []
+ ch = el.firstChild
+ while ch:
+ if ch.nodeType != xml.dom.Node.TEXT_NODE and ch.firstChild:
+ rv.append(_parse(ch))
+ ch=ch.nextSibling
+ return rv
+
+class BaseResponse(object):
+ """Base class for XML Response Handling."""
+
+ def __init__(self, el):
+ ch = el.firstChild
+ while ch:
+ if ch.nodeType != xml.dom.Node.TEXT_NODE and ch.firstChild:
+ ln = ch.localName.replace('-', '_')
+ self.__dict__[ln] = _parse(ch)
+ ch=ch.nextSibling
+
+ def __repr__(self):
+ return "<<%s>>" % str(self.__class__)
+
+class User(BaseResponse):
+ """A github user."""
+
+ parses = 'user'
+
+ def __repr__(self):
+ return "<>" % self.name
+
+class Plan(BaseResponse):
+ """A github plan."""
+
+ parses = 'plan'
+
+ def __repr__(self):
+ return "<>" % self.name
+
+class Repository(BaseResponse):
+ """A repository."""
+
+ parses = 'repository'
+
+ @property
+ def owner_name(self):
+ if hasattr(self, 'owner'):
+ return self.owner
+ else:
+ return self.username
+
+ def __repr__(self):
+ return "<>" % (self.owner_name, self.name)
+
+class PublicKey(BaseResponse):
+ """A public key."""
+
+ parses = 'public-key'
+ title = 'untitled'
+
+ def __repr__(self):
+ return "<>" % self.title
+
+class Commit(BaseResponse):
+ """A commit."""
+
+ parses = 'commit'
+
+ def __repr__(self):
+ return "<>" % self.id
+
+class Parent(Commit):
+ """A commit parent."""
+
+ parses = 'parent'
+
+class Author(User):
+ """A commit author."""
+
+ parses = 'author'
+
+class Committer(User):
+ """A commit committer."""
+
+ parses = 'committer'
+
+class Issue(BaseResponse):
+ """An issue within the issue tracker."""
+
+ parses = 'issue'
+
+ def __repr__(self):
+ return "<>" % self.number
+
+class Label(BaseResponse):
+ """A Label within the issue tracker."""
+ parses = 'label'
+
+ def __repr__(self):
+ return "<>" % self.number
+
+class Tree(BaseResponse):
+ """A Tree object."""
+
+ # Parsing is scoped to objects...
+ def __repr__(self):
+ return "<>" % self.name
+
+class Blob(BaseResponse):
+ """A Blob object."""
+
+ # Parsing is scoped to objects...
+ def __repr__(self):
+ return "<>" % self.name
+
+class Modification(BaseResponse):
+ """A modification object."""
+
+ # Parsing is scoped to usage
+ def __repr__(self):
+ return "<>" % self.filename
+
+class Network(BaseResponse):
+ """A network entry."""
+
+ parses = 'network'
+
+ def __repr__(self):
+ return "<>" % (self.owner, self.name)
+
+# Load the known types.
+for __t in (t for t in globals().values() if hasattr(t, 'parses')):
+ _types[__t.parses] = __t
+
+class BaseEndpoint(object):
+
+ BASE_URL = 'http://github.com/api/v2/xml/'
+
+ def __init__(self, user, token, fetcher):
+ self.user = user
+ self.token = token
+ self.fetcher = fetcher
+
+ def _raw_fetch(self, path):
+ p = self.BASE_URL + path
+ args = ''
+ if self.user and self.token:
+ params = '&'.join(['login=' + urllib.quote(self.user),
+ 'token=' + urllib.quote(self.token)])
+ if '?' in path:
+ p += params
+ else:
+ p += '?' + params
+ return self.fetcher(p).read()
+
+ def _fetch(self, path):
+ return xml.dom.minidom.parseString(self._raw_fetch(path))
+
+ def _post(self, path, **kwargs):
+ p = {'login': self.user, 'token': self.token}
+ p.update(kwargs)
+ return self.fetcher(self.BASE_URL + path, urllib.urlencode(p)).read()
+
+ def _parsed(self, path):
+ doc = self._fetch(path)
+ return _parse(doc.documentElement)
+
+ def _posted(self,path,**kwargs):
+ stuff = self._post(path,**kwargs)
+ doc = xml.dom.minidom.parseString(stuff)
+ return _parse(doc.documentElement)
+
+class UserEndpoint(BaseEndpoint):
+
+ def search(self, query):
+ """Search for a user."""
+ return self._parsed('user/search/' + query)
+
+ def show(self, username):
+ """Get the info for a user."""
+ return self._parsed('user/show/' + username)
+
+ def keys(self):
+ """Get the public keys for a user."""
+ return self._parsed('user/keys')
+
+ def removeKey(self, keyId):
+ """Remove the key with the given ID (as retrieved from keys)"""
+ self._post('user/key/remove', id=keyId)
+
+ def addKey(self, name, key):
+ """Add an ssh key."""
+ self._post('user/key/add', name=name, key=key)
+
+class RepositoryEndpoint(BaseEndpoint):
+
+ def forUser(self, username):
+ """Get the repositories for the given user."""
+ return self._parsed('repos/show/' + username)
+
+ def branches(self, user, repo):
+ """List the branches for a repo."""
+ doc = self._fetch("repos/show/" + user + "/" + repo + "/branches")
+ rv = {}
+ for c in doc.documentElement.childNodes:
+ if c.nodeType != xml.dom.Node.TEXT_NODE:
+ rv[c.localName] = str(c.firstChild.data)
+ return rv
+
+ def search(self, term):
+ """Search for repositories."""
+ return self._parsed('repos/search/' + urllib.quote_plus(term))
+
+ def show(self, user, repo):
+ """Lookup an individual repository."""
+ return self._parsed('/'.join(['repos', 'show', user, repo]))
+
+ def watch(self, user, repo):
+ """Watch a repository."""
+ self._post('repos/watch/' + user + '/' + repo)
+
+ def unwatch(self, user, repo):
+ """Stop watching a repository."""
+ self._post('repos/unwatch/' + user + '/' + repo)
+
+ def watched(self, user):
+ """Get watched repositories of a user."""
+ return self._parsed('repos/watched/' + user)
+
+ def network(self, user, repo):
+ """Get the network for a given repo."""
+ return self._parsed('repos/show/' + user + '/' + repo + '/network')
+
+ def setVisible(self, repo, public=True):
+ """Set the visibility of the given repository (owned by the current user)."""
+ if public:
+ path = 'repos/set/public/' + repo
+ else:
+ path = 'repos/set/private/' + repo
+ self._post(path)
+
+ def create(self, name, description='', homepage='', public=1):
+ """Create a new repository."""
+ self._post('repos/create', name=name, description=description,
+ homepage=homepage, public=str(public))
+
+ def delete(self, repo):
+ """Delete a repository."""
+ self._post('repos/delete/' + repo)
+
+ def fork(self, user, repo):
+ """Fork a user's repo."""
+ self._post('repos/fork/' + user + '/' + repo)
+
+ def collaborators(self, user, repo):
+ """Find all of the collaborators of one of your repositories."""
+ return self._parsed('repos/show/%s/%s/collaborators' % (user, repo))
+
+ def addCollaborator(self, repo, username):
+ """Add a collaborator to one of your repositories."""
+ self._post('repos/collaborators/' + repo + '/add/' + username)
+
+ def removeCollaborator(self, repo, username):
+ """Remove a collaborator from one of your repositories."""
+ self._post('repos/collaborators/' + repo + '/remove/' + username)
+
+ def collaborators_all(self):
+ """Find all of the collaborators of every of your repositories.
+
+ Returns a dictionary with reponame as key and a list of collaborators as value."""
+ ret = {}
+ for reponame in (rp.name for rp in self.forUser(self.user)):
+ ret[reponame] = self.collaborators(self.user, reponame)
+ return ret
+
+ def addCollaborator_all(self, username):
+ """Add a collaborator to all of your repositories."""
+ for reponame in (rp.name for rp in self.forUser(self.user)):
+ self.addCollaborator(reponame, username)
+
+ def removeCollaborator_all(self, username):
+ """Remove a collaborator from all of your repositories."""
+ for reponame in (rp.name for rp in self.forUser(self.user)):
+ self.removeCollaborator(reponame, username)
+
+ def deployKeys(self, repo):
+ """List the deploy keys for the given repository.
+
+ The repository must be owned by the current user."""
+ return self._parsed('repos/keys/' + repo)
+
+ def addDeployKey(self, repo, title, key):
+ """Add a deploy key to a repository."""
+ self._post('repos/key/' + repo + '/add', title=title, key=key)
+
+ def removeDeployKey(self, repo, keyId):
+ """Remove a deploy key."""
+ self._post('repos/key/' + repo + '/remove', id=keyId)
+
+class CommitEndpoint(BaseEndpoint):
+
+ def forBranch(self, user, repo, branch='master'):
+ """Get the commits for the given branch."""
+ return self._parsed('/'.join(['commits', 'list', user, repo, branch]))
+
+ def forFile(self, user, repo, path, branch='master'):
+ """Get the commits for the given file within the given branch."""
+ return self._parsed('/'.join(['commits', 'list', user, repo, branch, path]))
+
+ @with_temporary_mappings({'removed': _parseArray,
+ 'added': _parseArray,
+ 'modified': Modification,
+ 'diff': _string_parser,
+ 'filename': _string_parser})
+ def show(self, user, repo, sha):
+ """Get an individual commit."""
+ c = self._parsed('/'.join(['commits', 'show', user, repo, sha]))
+ # Some fixup due to weird XML structure
+ if hasattr(c, 'removed'):
+ c.removed = [i[0] for i in c.removed]
+ if hasattr(c, 'added'):
+ c.added = [i[0] for i in c.added]
+ return c
+
+class IssuesEndpoint(BaseEndpoint):
+
+ @with_temporary_mappings({'user': None})
+ def list(self, user, repo, state='open'):
+ """Get the list of issues for the given repo in the given state."""
+ return self._parsed('/'.join(['issues', 'list', user, repo, state]))
+
+ @with_temporary_mappings({'user': None})
+ def show(self, user, repo, issue_id):
+ """Show an individual issue."""
+ return self._parsed('/'.join(['issues', 'show', user, repo, str(issue_id)]))
+
+ def add_label(self, user, repo, issue_id, label):
+ """Add a label to an issue."""
+ self._post('issues/label/add/' + user + '/'
+ + repo + '/' + label + '/' + str(issue_id))
+
+ def remove_label(self, user, repo, issue_id, label):
+ """Remove a label from an issue."""
+ self._post('issues/label/remove/' + user + '/'
+ + repo + '/' + label + '/' + str(issue_id))
+
+ def close(self, user, repo, issue_id):
+ """Close an issue."""
+ self._post('/'.join(['issues', 'close', user, repo, str(issue_id)]))
+
+ def reopen(self, user, repo, issue_id):
+ """Reopen an issue."""
+ self._post('/'.join(['issues', 'reopen', user, repo, str(issue_id)]))
+
+ def new(self, user, repo, title, body=''):
+ """Create a new issue."""
+ return self._posted('/'.join(['issues', 'open', user, repo]),
+ title=title, body=body)
+
+ def edit(self, user, repo, issue_id, title, body):
+ """Create a new issue."""
+ self._post('/'.join(['issues', 'edit', user, repo, str(issue_id)]),
+ title=title, body=body)
+
+class ObjectsEndpoint(BaseEndpoint):
+
+ @with_temporary_mappings({'tree': Tree, 'type': _string_parser})
+ def tree(self, user, repo, t):
+ """Get the given tree from the given repo."""
+ tl = self._parsed('/'.join(['tree', 'show', user, repo, t]))
+ return dict([(t.name, t) for t in tl])
+
+ @with_temporary_mappings({'blob': Blob})
+ def blob(self, user, repo, t, fn):
+ return self._parsed('/'.join(['blob', 'show', user, repo, t, fn]))
+
+ def raw_blob(self, user, repo, sha):
+ """Get a raw blob from a repo."""
+ path = 'blob/show/%s/%s/%s' % (user, repo, sha)
+ return self._raw_fetch(path)
+
+class GitHub(object):
+ """Interface to github."""
+
+ def __init__(self, user=None, token=None, fetcher=default_fetcher):
+ self.user = user
+ self.token = token
+ self.fetcher = fetcher
+
+ @property
+ def users(self):
+ """Get access to the user API."""
+ return UserEndpoint(self.user, self.token, self.fetcher)
+
+ @property
+ def repos(self):
+ """Get access to the user API."""
+ return RepositoryEndpoint(self.user, self.token, self.fetcher)
+
+ @property
+ def commits(self):
+ return CommitEndpoint(self.user, self.token, self.fetcher)
+
+ @property
+ def issues(self):
+ return IssuesEndpoint(self.user, self.token, self.fetcher)
+
+ @property
+ def objects(self):
+ return ObjectsEndpoint(self.user, self.token, self.fetcher)
diff --git a/lib/pygithub/githubsync.py b/lib/pygithub/githubsync.py
new file mode 100644
index 00000000..50d70a07
--- /dev/null
+++ b/lib/pygithub/githubsync.py
@@ -0,0 +1,88 @@
+#!/usr/bin/env python
+#
+# Copyright (c) 2005-2008 Dustin Sallings
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+#
+#
+"""
+Grab all of a user's projects from github.
+"""
+
+import os
+import sys
+import subprocess
+
+import github
+
+def check_for_old_format(path, url):
+ p = subprocess.Popen(['git', '--git-dir=' + path, 'config',
+ 'remote.origin.fetch'], stdout = subprocess.PIPE)
+ stdout, stderr = p.communicate()
+ if stdout.strip() != '+refs/*:refs/*':
+ print "Not properly configured for mirroring, repairing."
+ subprocess.call(['git', '--git-dir=' + path, 'remote', 'rm', 'origin'])
+ add_mirror(path, url)
+
+def add_mirror(path, url):
+ subprocess.call(['git', '--git-dir=' + path, 'remote', 'add', '--mirror',
+ 'origin', url])
+
+def sync(path, url, repo_name):
+ p = os.path.join(path, repo_name) + ".git"
+ print "Syncing %s -> %s" % (repo_name, p)
+ if not os.path.exists(p):
+ subprocess.call(['git', 'clone', '--bare', url, p])
+ add_mirror(p, url)
+ check_for_old_format(p, url)
+ subprocess.call(['git', '--git-dir=' + p, 'fetch', '-f'])
+
+def sync_user_repo(path, repo):
+ sync(path, "git://github.com/%s/%s" % (repo.owner, repo.name), repo.name)
+
+def usage():
+ sys.stderr.write("Usage: %s username destination_url\n" % sys.argv[0])
+ sys.stderr.write(
+ """Ensures you've got the latest stuff for the given user.
+
+Also, if the file $HOME/.github-private exists, it will be read for
+additional projects.
+
+Each line must be a simple project name (e.g. py-github), a tab character,
+and a git URL.
+""")
+
+if __name__ == '__main__':
+ try:
+ user, path = sys.argv[1:]
+ except ValueError:
+ usage()
+ exit(1)
+
+ privfile = os.path.join(os.getenv("HOME"), ".github-private")
+ if os.path.exists(privfile):
+ f = open(privfile)
+ for line in f:
+ name, url = line.strip().split("\t")
+ sync(path, url, name)
+
+ gh = github.GitHub()
+
+ for repo in gh.repos.forUser(user):
+ sync_user_repo(path, repo)
diff --git a/lib/pygithub/githubtest.py b/lib/pygithub/githubtest.py
new file mode 100644
index 00000000..bfb73cd8
--- /dev/null
+++ b/lib/pygithub/githubtest.py
@@ -0,0 +1,493 @@
+#!/usr/bin/env python
+#
+# Copyright (c) 2005-2008 Dustin Sallings
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+#
+#
+"""
+Defines and runs unittests.
+"""
+
+import urllib
+import hashlib
+import unittest
+
+import github
+
+class BaseCase(unittest.TestCase):
+
+ def _gh(self, expUrl, filename):
+
+ def opener(url):
+ self.assertEquals(expUrl, url)
+ return open(filename)
+ return github.GitHub(fetcher=opener)
+
+ def _agh(self, expUrl, u, t, filename):
+
+ def opener(url):
+ self.assertEquals(expUrl, url + '?login=' + u + '&token=' + t)
+ return open(filename)
+ return github.GitHub(fetcher=opener)
+
+ def _ghp(self, expUrl, u, t, **kv):
+
+ def opener(url, data):
+ h = {'login': u, 'token': t}
+ h.update(kv)
+ self.assertEquals(github.BaseEndpoint.BASE_URL + expUrl, url)
+ self.assertEquals(sorted(data.split('&')),
+ sorted(urllib.urlencode(h).split('&')))
+ return github.GitHub(u, t, fetcher=opener)
+
+class UserTest(BaseCase):
+
+ def __loadUserSearch(self):
+ return self._gh('http://github.com/api/v2/xml/user/search/dustin',
+ 'data/user.search.xml').users.search('dustin')
+
+ def __loadUser(self, which, u=None, p=None):
+ if u:
+ return self._agh('http://github.com/api/v2/xml/user/show/dustin'
+ + '?login=' + u + '&token=' + p,
+ u, p, 'data/' + which).users.show('dustin')
+
+ else:
+ return self._gh('http://github.com/api/v2/xml/user/show/dustin',
+ 'data/' + which).users.show('dustin')
+
+ def testUserSearch(self):
+ """Test the base properties of the user object."""
+ u = self.__loadUserSearch()[0]
+ self.assertEquals("Dustin Sallings", u.fullname)
+ self.assertEquals("dustin", u.name)
+ self.assertEquals("dustin@spy.net", u.email)
+ self.assertEquals("Santa Clara, CA", u.location)
+ self.assertEquals("Ruby", u.language)
+ self.assertEquals(35, u.actions)
+ self.assertEquals(77, u.repos)
+ self.assertEquals(78, u.followers)
+ self.assertEquals('user-1779', u.id)
+ self.assertAlmostEquals(12.231684, u.score)
+ self.assertEquals('user', u.type)
+ self.assertEquals('2008-02-29T17:59:09Z', u.created)
+ self.assertEquals('2009-03-19T09:15:24.663Z', u.pushed)
+ self.assertEquals("<>", repr(u))
+
+ def testUserPublic(self):
+ """Test the user show API with no authentication."""
+ u = self.__loadUser('user.public.xml')
+ self.assertEquals("Dustin Sallings", u.name)
+ # self.assertEquals(None, u.company)
+ self.assertEquals(10, u.following_count)
+ self.assertEquals(21, u.public_gist_count)
+ self.assertEquals(81, u.public_repo_count)
+ self.assertEquals('http://bleu.west.spy.net/~dustin/', u.blog)
+ self.assertEquals(1779, u.id)
+ self.assertEquals(82, u.followers_count)
+ self.assertEquals('dustin', u.login)
+ self.assertEquals('Santa Clara, CA', u.location)
+ self.assertEquals('dustin@spy.net', u.email)
+ self.assertEquals('2008-02-29T09:59:09-08:00', u.created_at)
+
+ def testUserPrivate(self):
+ """Test the user show API with extra info from auth."""
+ u = self.__loadUser('user.private.xml', 'dustin', 'blahblah')
+ self.assertEquals("Dustin Sallings", u.name)
+ # self.assertEquals(None, u.company)
+ self.assertEquals(10, u.following_count)
+ self.assertEquals(21, u.public_gist_count)
+ self.assertEquals(81, u.public_repo_count)
+ self.assertEquals('http://bleu.west.spy.net/~dustin/', u.blog)
+ self.assertEquals(1779, u.id)
+ self.assertEquals(82, u.followers_count)
+ self.assertEquals('dustin', u.login)
+ self.assertEquals('Santa Clara, CA', u.location)
+ self.assertEquals('dustin@spy.net', u.email)
+ self.assertEquals('2008-02-29T09:59:09-08:00', u.created_at)
+
+ # Begin private data
+
+ self.assertEquals("micro", u.plan.name)
+ self.assertEquals(1, u.plan.collaborators)
+ self.assertEquals(614400, u.plan.space)
+ self.assertEquals(5, u.plan.private_repos)
+ self.assertEquals(155191, u.disk_usage)
+ self.assertEquals(6, u.collaborators)
+ self.assertEquals(4, u.owned_private_repo_count)
+ self.assertEquals(5, u.total_private_repo_count)
+ self.assertEquals(0, u.private_gist_count)
+
+ def testKeysList(self):
+ """Test key listing."""
+ kl = self._agh('http://github.com/api/v2/xml/user/keys?login=dustin&token=blahblah',
+ 'dustin', 'blahblah', 'data/keys.xml').users.keys()
+ self.assertEquals(7, len(kl))
+ k = kl[0]
+
+ self.assertEquals('some key', k.title)
+ self.assertEquals(2181, k.id)
+ self.assertEquals(549, k.key.find('cdEXwCSjAIFp8iRqh3GOkxGyFSc25qv/MuOBg=='))
+
+ def testRemoveKey(self):
+ """Remove a key."""
+ self._ghp('user/key/remove',
+ 'dustin', 'p', id=828).users.removeKey(828)
+
+ def testAddKey(self):
+ """Add a key."""
+ self._ghp('user/key/add',
+ 'dustin', 'p', name='my key', key='some key').users.addKey(
+ 'my key', 'some key')
+
+class RepoTest(BaseCase):
+
+ def __loadUserRepos(self):
+ return self._gh('http://github.com/api/v2/xml/repos/show/verbal',
+ 'data/repos.xml').repos.forUser('verbal')
+
+ def testUserRepoList(self):
+ """Get a list of repos for a user."""
+ rs = self.__loadUserRepos()
+ self.assertEquals(10, len(rs))
+ r = rs[0]
+ self.assertEquals('A beanstalk client for the twisted network framework.',
+ r.description)
+ self.assertEquals(2, r.watchers)
+ self.assertEquals(0, r.forks)
+ self.assertEquals('beanstalk-client-twisted', r.name)
+ self.assertEquals(False, r.private)
+ self.assertEquals('http://github.com/verbal/beanstalk-client-twisted',
+ r.url)
+ self.assertEquals(True, r.fork)
+ self.assertEquals('verbal', r.owner)
+ # XXX: Can't parse empty elements. :(
+ # self.assertEquals('', r.homepage)
+
+ def testRepoSearch(self):
+ """Test searching a repository."""
+ rl = self._gh('http://github.com/api/v2/xml/repos/search/ruby+testing',
+ 'data/repos.search.xml').repos.search('ruby testing')
+ self.assertEquals(12, len(rl))
+
+ r = rl[0]
+ self.assertEquals('synthesis', r.name)
+ self.assertAlmostEquals(0.3234576, r.score, 4)
+ self.assertEquals(4656, r.actions)
+ self.assertEquals(2048, r.size)
+ self.assertEquals('Ruby', r.language)
+ self.assertEquals(26, r.followers)
+ self.assertEquals('gmalamid', r.username)
+ self.assertEquals('repo', r.type)
+ self.assertEquals('repo-3555', r.id)
+ self.assertEquals(1, r.forks)
+ self.assertFalse(r.fork)
+ self.assertEquals('Ruby test code analysis tool employing a '
+ '"Synthesized Testing" strategy, aimed to reduce '
+ 'the volume of slower, coupled, complex wired tests.',
+ r.description)
+ self.assertEquals('2009-01-08T13:45:06Z', r.pushed)
+ self.assertEquals('2008-03-11T23:38:04Z', r.created)
+
+ def testBranchList(self):
+ """Test branch listing for a repo."""
+ bl = self._gh('http://github.com/api/v2/xml/repos/show/schacon/ruby-git/branches',
+ 'data/repos.branches.xml').repos.branches('schacon', 'ruby-git')
+ self.assertEquals(4, len(bl))
+ self.assertEquals('ee90922f3da3f67ef19853a0759c1d09860fe3b3', bl['master'])
+
+ def testGetOneRepo(self):
+ """Fetch an individual repository."""
+ r = self._gh('http://github.com/api/v2/xml/repos/show/schacon/grit',
+ 'data/repo.xml').repos.show('schacon', 'grit')
+
+ self.assertEquals('Grit is a Ruby library for extracting information from a '
+ 'git repository in an object oriented manner - this fork '
+ 'tries to intergrate as much pure-ruby functionality as possible',
+ r.description)
+ self.assertEquals(68, r.watchers)
+ self.assertEquals(4, r.forks)
+ self.assertEquals('grit', r.name)
+ self.assertFalse(r.private)
+ self.assertEquals('http://github.com/schacon/grit', r.url)
+ self.assertTrue(r.fork)
+ self.assertEquals('schacon', r.owner)
+ self.assertEquals('http://grit.rubyforge.org/', r.homepage)
+
+ def testGetRepoNetwork(self):
+ """Test network fetching."""
+ nl = self._gh('http://github.com/api/v2/xml/repos/show/dustin/py-github/network',
+ 'data/network.xml').repos.network('dustin', 'py-github')
+ self.assertEquals(5, len(nl))
+
+ n = nl[0]
+ self.assertEquals('Python interface for talking to the github API',
+ n.description)
+ self.assertEquals('py-github', n.name)
+ self.assertFalse(n.private)
+ self.assertEquals('http://github.com/dustin/py-github', n.url)
+ self.assertEquals(30, n.watchers)
+ self.assertEquals(4, n.forks)
+ self.assertFalse(n.fork)
+ self.assertEquals('dustin', n.owner)
+ self.assertEquals('http://dustin.github.com/2008/12/29/github-sync.html',
+ n.homepage)
+
+ def testSetPublic(self):
+ """Test setting a repo visible."""
+ self._ghp('repos/set/public/py-github', 'dustin', 'p').repos.setVisible(
+ 'py-github')
+
+ def testSetPrivate(self):
+ """Test setting a repo to private."""
+ self._ghp('repos/set/private/py-github', 'dustin', 'p').repos.setVisible(
+ 'py-github', False)
+
+ def testCreateRepository(self):
+ """Test creating a repository."""
+ self._ghp('repos/create', 'dustin', 'p',
+ name='testrepo',
+ description='woo',
+ homepage='',
+ public='1').repos.create(
+ 'testrepo', description='woo')
+
+ def testDeleteRepo(self):
+ """Test setting a repo to private."""
+ self._ghp('repos/delete/mytest', 'dustin', 'p').repos.delete('mytest')
+
+ def testFork(self):
+ """Test forking'"""
+ self._ghp('repos/fork/someuser/somerepo', 'dustin', 'p').repos.fork(
+ 'someuser', 'somerepo')
+
+ def testAddCollaborator(self):
+ """Adding a collaborator."""
+ self._ghp('repos/collaborators/memcached/add/trondn',
+ 'dustin', 'p').repos.addCollaborator('memcached', 'trondn')
+
+ def testRemoveCollaborator(self):
+ """Removing a collaborator."""
+ self._ghp('repos/collaborators/memcached/remove/trondn',
+ 'dustin', 'p').repos.removeCollaborator('memcached', 'trondn')
+
+ def testAddDeployKey(self):
+ """Add a deploy key."""
+ self._ghp('repos/key/blah/add', 'dustin', 'p',
+ title='title', key='key').repos.addDeployKey('blah', 'title', 'key')
+
+ def testRemoveDeployKey(self):
+ """Remove a deploy key."""
+ self._ghp('repos/key/blah/remove', 'dustin', 'p',
+ id=5).repos.removeDeployKey('blah', 5)
+
+class CommitTest(BaseCase):
+
+ def testCommitList(self):
+ """Test commit list."""
+ cl = self._gh('http://github.com/api/v2/xml/commits/list/mojombo/grit/master',
+ 'data/commits.xml').commits.forBranch('mojombo', 'grit')
+ self.assertEquals(30, len(cl))
+
+ c = cl[0]
+ self.assertEquals("Regenerated gemspec for version 1.1.1", c.message)
+ self.assertEquals('4ac4acab7fd9c7fd4c0e0f4ff5794b0347baecde', c.id)
+ self.assertEquals('94490563ebaf733cbb3de4ad659eb58178c2e574', c.tree)
+ self.assertEquals('2009-03-31T09:54:51-07:00', c.committed_date)
+ self.assertEquals('2009-03-31T09:54:51-07:00', c.authored_date)
+ self.assertEquals('http://github.com/mojombo/grit/commit/4ac4acab7fd9c7fd4c0e0f4ff5794b0347baecde',
+ c.url)
+ self.assertEquals(1, len(c.parents))
+ self.assertEquals('5071bf9fbfb81778c456d62e111440fdc776f76c', c.parents[0].id)
+ self.assertEquals('Tom Preston-Werner', c.author.name)
+ self.assertEquals('tom@mojombo.com', c.author.email)
+ self.assertEquals('Tom Preston-Werner', c.committer.name)
+ self.assertEquals('tom@mojombo.com', c.committer.email)
+
+ def testCommitListForFile(self):
+ """Test commit list for a file."""
+ cl = self._gh('http://github.com/api/v2/xml/commits/list/mojombo/grit/master/grit.gemspec',
+ 'data/commits.xml').commits.forFile('mojombo', 'grit', 'grit.gemspec')
+ self.assertEquals(30, len(cl))
+
+ c = cl[0]
+ self.assertEquals("Regenerated gemspec for version 1.1.1", c.message)
+ self.assertEquals('4ac4acab7fd9c7fd4c0e0f4ff5794b0347baecde', c.id)
+ self.assertEquals('94490563ebaf733cbb3de4ad659eb58178c2e574', c.tree)
+ self.assertEquals('2009-03-31T09:54:51-07:00', c.committed_date)
+ self.assertEquals('2009-03-31T09:54:51-07:00', c.authored_date)
+ self.assertEquals('http://github.com/mojombo/grit/commit/4ac4acab7fd9c7fd4c0e0f4ff5794b0347baecde',
+ c.url)
+ self.assertEquals(1, len(c.parents))
+ self.assertEquals('5071bf9fbfb81778c456d62e111440fdc776f76c', c.parents[0].id)
+ self.assertEquals('Tom Preston-Werner', c.author.name)
+ self.assertEquals('tom@mojombo.com', c.author.email)
+ self.assertEquals('Tom Preston-Werner', c.committer.name)
+ self.assertEquals('tom@mojombo.com', c.committer.email)
+
+ def testIndividualCommit(self):
+ """Grab a single commit."""
+ h = '4c86fa592fcc7cb685c6e9d8b6aebe8dcbac6b3e'
+ c = self._gh('http://github.com/api/v2/xml/commits/show/dustin/memcached/' + h,
+ 'data/commit.xml').commits.show('dustin', 'memcached', h)
+ self.assertEquals(['internal_tests.c'], c.removed)
+ self.assertEquals(set(['cache.c', 'cache.h', 'testapp.c']), set(c.added))
+ self.assertEquals('Create a generic cache for objects of same size\n\n'
+ 'The suffix pool could be thread-local and use the generic cache',
+ c.message)
+
+ self.assertEquals(6, len(c.modified))
+ self.assertEquals('.gitignore', c.modified[0].filename)
+ self.assertEquals(140, len(c.modified[0].diff))
+
+ self.assertEquals(['ee0c3d5ae74d0862b4d9990e2ad13bc79f8c34df'],
+ [p.id for p in c.parents])
+ self.assertEquals('http://github.com/dustin/memcached/commit/' + h, c.url)
+ self.assertEquals('Trond Norbye', c.author.name)
+ self.assertEquals('Trond.Norbye@sun.com', c.author.email)
+ self.assertEquals(h, c.id)
+ self.assertEquals('2009-04-17T16:15:52-07:00', c.committed_date)
+ self.assertEquals('2009-03-27T10:30:16-07:00', c.authored_date)
+ self.assertEquals('94b644163f6381a9930e2d7c583fae023895b903', c.tree)
+ self.assertEquals('Dustin Sallings', c.committer.name)
+ self.assertEquals('dustin@spy.net', c.committer.email)
+
+ def testWatchRepo(self):
+ """Test watching a repo."""
+ self._ghp('repos/watch/dustin/py-github', 'dustin', 'p').repos.watch(
+ 'dustin', 'py-github')
+
+ def testWatchRepo(self):
+ """Test watching a repo."""
+ self._ghp('repos/unwatch/dustin/py-github', 'dustin', 'p').repos.unwatch(
+ 'dustin', 'py-github')
+
+class IssueTest(BaseCase):
+
+ def testListIssues(self):
+ """Test listing issues."""
+ il = self._gh('http://github.com/api/v2/xml/issues/list/schacon/simplegit/open',
+ 'data/issues.list.xml').issues.list('schacon', 'simplegit')
+ self.assertEquals(1, len(il))
+ i = il[0]
+
+ self.assertEquals('schacon', i.user)
+ self.assertEquals('2009-04-17T16:19:02-07:00', i.updated_at)
+ self.assertEquals('something', i.body)
+ self.assertEquals('new', i.title)
+ self.assertEquals(2, i.number)
+ self.assertEquals(0, i.votes)
+ self.assertEquals(1.0, i.position)
+ self.assertEquals('2009-04-17T16:18:50-07:00', i.created_at)
+ self.assertEquals('open', i.state)
+
+ def testShowIssue(self):
+ """Show an individual issue."""
+ i = self._gh('http://github.com/api/v2/xml/issues/show/dustin/py-github/1',
+ 'data/issues.show.xml').issues.show('dustin', 'py-github', 1)
+
+ self.assertEquals('dustin', i.user)
+ self.assertEquals('2009-04-17T18:37:04-07:00', i.updated_at)
+ self.assertEquals('http://develop.github.com/p/general.html', i.body)
+ self.assertEquals('Add auth tokens', i.title)
+ self.assertEquals(1, i.number)
+ self.assertEquals(0, i.votes)
+ self.assertEquals(1.0, i.position)
+ self.assertEquals('2009-04-17T17:00:58-07:00', i.created_at)
+ self.assertEquals('closed', i.state)
+
+ def testAddLabel(self):
+ """Adding a label to an issue."""
+ self._ghp('issues/label/add/dustin/py-github/todo/33', 'd', 'pw').issues.add_label(
+ 'dustin', 'py-github', 33, 'todo')
+
+ def testRemoveLabel(self):
+ """Removing a label from an issue."""
+ self._ghp('issues/label/remove/dustin/py-github/todo/33',
+ 'd', 'pw').issues.remove_label(
+ 'dustin', 'py-github', 33, 'todo')
+
+ def testCloseIssue(self):
+ """Closing an issue."""
+ self._ghp('issues/close/dustin/py-github/1', 'd', 'pw').issues.close(
+ 'dustin', 'py-github', 1)
+
+ def testReopenIssue(self):
+ """Reopening an issue."""
+ self._ghp('issues/reopen/dustin/py-github/1', 'd', 'pw').issues.reopen(
+ 'dustin', 'py-github', 1)
+
+ def testCreateIssue(self):
+ """Creating an issue."""
+ self._ghp('issues/open/dustin/py-github', 'd', 'pw',
+ title='test title', body='').issues.new(
+ 'dustin', 'py-github', title='test title')
+
+ def testEditIssue(self):
+ """Editing an existing issue."""
+ self._ghp('issues/edit/dustin/py-github/1', 'd', 'pw',
+ title='new title', body='new body').issues.edit(
+ 'dustin', 'py-github', 1, 'new title', 'new body')
+
+class ObjectTest(BaseCase):
+
+ def testTree(self):
+ """Test tree fetching."""
+ h = '1ddd3f99f0b96019042239375b3ad4d45796ffba'
+ tl = self._gh('http://github.com/api/v2/xml/tree/show/dustin/py-github/' + h,
+ 'data/tree.xml').objects.tree('dustin', 'py-github', h)
+ self.assertEquals(8, len(tl))
+ self.assertEquals('setup.py', tl['setup.py'].name)
+ self.assertEquals('6e290379ec58fa00ac9d1c2a78f0819a21397445',
+ tl['setup.py'].sha)
+ self.assertEquals('100755', tl['setup.py'].mode)
+ self.assertEquals('blob', tl['setup.py'].type)
+
+ self.assertEquals('src', tl['src'].name)
+ self.assertEquals('5fb9175803334c82b3fd66f1b69502691b91cf4f',
+ tl['src'].sha)
+ self.assertEquals('040000', tl['src'].mode)
+ self.assertEquals('tree', tl['src'].type)
+
+ def testBlob(self):
+ """Test blob fetching."""
+ h = '1ddd3f99f0b96019042239375b3ad4d45796ffba'
+ blob = self._gh('http://github.com/api/v2/xml/blob/show/dustin/py-github/'
+ + h + '/setup.py',
+ 'data/blob.xml').objects.blob('dustin', 'py-github', h, 'setup.py')
+ self.assertEquals('setup.py', blob.name)
+ self.assertEquals(1842, blob.size)
+ self.assertEquals('6e290379ec58fa00ac9d1c2a78f0819a21397445', blob.sha)
+ self.assertEquals('100755', blob.mode)
+ self.assertEquals('text/plain', blob.mime_type)
+ self.assertEquals(1842, len(blob.data))
+ self.assertEquals(1641, blob.data.index('Production/Stable'))
+
+ def testRawBlob(self):
+ """Test raw blob fetching."""
+ h = '6e290379ec58fa00ac9d1c2a78f0819a21397445'
+ blob = self._gh('http://github.com/api/v2/xml/blob/show/dustin/py-github/' + h,
+ 'data/setup.py').objects.raw_blob('dustin', 'py-github', h)
+ self.assertEquals('e2dc8aea9ae8961f4f5923f9febfdd0a',
+ hashlib.md5(blob).hexdigest())
+
+
+if __name__ == '__main__':
+ unittest.main()
diff --git a/mako/__init__.py b/mako/__init__.py
new file mode 100644
index 00000000..c0f78adc
--- /dev/null
+++ b/mako/__init__.py
@@ -0,0 +1,9 @@
+# mako/__init__.py
+# Copyright (C) 2006-2011 the Mako authors and contributors
+#
+# This module is part of Mako and is released under
+# the MIT License: http://www.opensource.org/licenses/mit-license.php
+
+
+__version__ = '0.4.1'
+
diff --git a/mako/_ast_util.py b/mako/_ast_util.py
new file mode 100644
index 00000000..9521ccbb
--- /dev/null
+++ b/mako/_ast_util.py
@@ -0,0 +1,839 @@
+# mako/_ast_util.py
+# Copyright (C) 2006-2011 the Mako authors and contributors
+#
+# This module is part of Mako and is released under
+# the MIT License: http://www.opensource.org/licenses/mit-license.php
+
+"""
+ ast
+ ~~~
+
+ The `ast` module helps Python applications to process trees of the Python
+ abstract syntax grammar. The abstract syntax itself might change with
+ each Python release; this module helps to find out programmatically what
+ the current grammar looks like and allows modifications of it.
+
+ An abstract syntax tree can be generated by passing `ast.PyCF_ONLY_AST` as
+ a flag to the `compile()` builtin function or by using the `parse()`
+ function from this module. The result will be a tree of objects whose
+ classes all inherit from `ast.AST`.
+
+ A modified abstract syntax tree can be compiled into a Python code object
+ using the built-in `compile()` function.
+
+ Additionally various helper functions are provided that make working with
+ the trees simpler. The main intention of the helper functions and this
+ module in general is to provide an easy to use interface for libraries
+ that work tightly with the python syntax (template engines for example).
+
+
+ :copyright: Copyright 2008 by Armin Ronacher.
+ :license: Python License.
+"""
+from _ast import *
+
+
+BOOLOP_SYMBOLS = {
+ And: 'and',
+ Or: 'or'
+}
+
+BINOP_SYMBOLS = {
+ Add: '+',
+ Sub: '-',
+ Mult: '*',
+ Div: '/',
+ FloorDiv: '//',
+ Mod: '%',
+ LShift: '<<',
+ RShift: '>>',
+ BitOr: '|',
+ BitAnd: '&',
+ BitXor: '^'
+}
+
+CMPOP_SYMBOLS = {
+ Eq: '==',
+ Gt: '>',
+ GtE: '>=',
+ In: 'in',
+ Is: 'is',
+ IsNot: 'is not',
+ Lt: '<',
+ LtE: '<=',
+ NotEq: '!=',
+ NotIn: 'not in'
+}
+
+UNARYOP_SYMBOLS = {
+ Invert: '~',
+ Not: 'not',
+ UAdd: '+',
+ USub: '-'
+}
+
+ALL_SYMBOLS = {}
+ALL_SYMBOLS.update(BOOLOP_SYMBOLS)
+ALL_SYMBOLS.update(BINOP_SYMBOLS)
+ALL_SYMBOLS.update(CMPOP_SYMBOLS)
+ALL_SYMBOLS.update(UNARYOP_SYMBOLS)
+
+
+def parse(expr, filename='', mode='exec'):
+ """Parse an expression into an AST node."""
+ return compile(expr, filename, mode, PyCF_ONLY_AST)
+
+
+def to_source(node, indent_with=' ' * 4):
+ """
+ This function can convert a node tree back into python sourcecode. This
+ is useful for debugging purposes, especially if you're dealing with custom
+ asts not generated by python itself.
+
+ It could be that the sourcecode is evaluable when the AST itself is not
+ compilable / evaluable. The reason for this is that the AST contains some
+ more data than regular sourcecode does, which is dropped during
+ conversion.
+
+ Each level of indentation is replaced with `indent_with`. Per default this
+ parameter is equal to four spaces as suggested by PEP 8, but it might be
+ adjusted to match the application's styleguide.
+ """
+ generator = SourceGenerator(indent_with)
+ generator.visit(node)
+ return ''.join(generator.result)
+
+
+def dump(node):
+ """
+ A very verbose representation of the node passed. This is useful for
+ debugging purposes.
+ """
+ def _format(node):
+ if isinstance(node, AST):
+ return '%s(%s)' % (node.__class__.__name__,
+ ', '.join('%s=%s' % (a, _format(b))
+ for a, b in iter_fields(node)))
+ elif isinstance(node, list):
+ return '[%s]' % ', '.join(_format(x) for x in node)
+ return repr(node)
+ if not isinstance(node, AST):
+ raise TypeError('expected AST, got %r' % node.__class__.__name__)
+ return _format(node)
+
+
+def copy_location(new_node, old_node):
+ """
+ Copy the source location hint (`lineno` and `col_offset`) from the
+ old to the new node if possible and return the new one.
+ """
+ for attr in 'lineno', 'col_offset':
+ if attr in old_node._attributes and attr in new_node._attributes \
+ and hasattr(old_node, attr):
+ setattr(new_node, attr, getattr(old_node, attr))
+ return new_node
+
+
+def fix_missing_locations(node):
+ """
+ Some nodes require a line number and the column offset. Without that
+ information the compiler will abort the compilation. Because it can be
+ a dull task to add appropriate line numbers and column offsets when
+ adding new nodes this function can help. It copies the line number and
+ column offset of the parent node to the child nodes without this
+ information.
+
+ Unlike `copy_location` this works recursive and won't touch nodes that
+ already have a location information.
+ """
+ def _fix(node, lineno, col_offset):
+ if 'lineno' in node._attributes:
+ if not hasattr(node, 'lineno'):
+ node.lineno = lineno
+ else:
+ lineno = node.lineno
+ if 'col_offset' in node._attributes:
+ if not hasattr(node, 'col_offset'):
+ node.col_offset = col_offset
+ else:
+ col_offset = node.col_offset
+ for child in iter_child_nodes(node):
+ _fix(child, lineno, col_offset)
+ _fix(node, 1, 0)
+ return node
+
+
+def increment_lineno(node, n=1):
+ """
+ Increment the line numbers of all nodes by `n` if they have line number
+ attributes. This is useful to "move code" to a different location in a
+ file.
+ """
+ for node in zip((node,), walk(node)):
+ if 'lineno' in node._attributes:
+ node.lineno = getattr(node, 'lineno', 0) + n
+
+
+def iter_fields(node):
+ """Iterate over all fields of a node, only yielding existing fields."""
+ # CPython 2.5 compat
+ if not hasattr(node, '_fields') or not node._fields:
+ return
+ for field in node._fields:
+ try:
+ yield field, getattr(node, field)
+ except AttributeError:
+ pass
+
+
+def get_fields(node):
+ """Like `iter_fiels` but returns a dict."""
+ return dict(iter_fields(node))
+
+
+def iter_child_nodes(node):
+ """Iterate over all child nodes or a node."""
+ for name, field in iter_fields(node):
+ if isinstance(field, AST):
+ yield field
+ elif isinstance(field, list):
+ for item in field:
+ if isinstance(item, AST):
+ yield item
+
+
+def get_child_nodes(node):
+ """Like `iter_child_nodes` but returns a list."""
+ return list(iter_child_nodes(node))
+
+
+def get_compile_mode(node):
+ """
+ Get the mode for `compile` of a given node. If the node is not a `mod`
+ node (`Expression`, `Module` etc.) a `TypeError` is thrown.
+ """
+ if not isinstance(node, mod):
+ raise TypeError('expected mod node, got %r' % node.__class__.__name__)
+ return {
+ Expression: 'eval',
+ Interactive: 'single'
+ }.get(node.__class__, 'expr')
+
+
+def get_docstring(node):
+ """
+ Return the docstring for the given node or `None` if no docstring can be
+ found. If the node provided does not accept docstrings a `TypeError`
+ will be raised.
+ """
+ if not isinstance(node, (FunctionDef, ClassDef, Module)):
+ raise TypeError("%r can't have docstrings" % node.__class__.__name__)
+ if node.body and isinstance(node.body[0], Str):
+ return node.body[0].s
+
+
+def walk(node):
+ """
+ Iterate over all nodes. This is useful if you only want to modify nodes in
+ place and don't care about the context or the order the nodes are returned.
+ """
+ from collections import deque
+ todo = deque([node])
+ while todo:
+ node = todo.popleft()
+ todo.extend(iter_child_nodes(node))
+ yield node
+
+
+class NodeVisitor(object):
+ """
+ Walks the abstract syntax tree and call visitor functions for every node
+ found. The visitor functions may return values which will be forwarded
+ by the `visit` method.
+
+ Per default the visitor functions for the nodes are ``'visit_'`` +
+ class name of the node. So a `TryFinally` node visit function would
+ be `visit_TryFinally`. This behavior can be changed by overriding
+ the `get_visitor` function. If no visitor function exists for a node
+ (return value `None`) the `generic_visit` visitor is used instead.
+
+ Don't use the `NodeVisitor` if you want to apply changes to nodes during
+ traversing. For this a special visitor exists (`NodeTransformer`) that
+ allows modifications.
+ """
+
+ def get_visitor(self, node):
+ """
+ Return the visitor function for this node or `None` if no visitor
+ exists for this node. In that case the generic visit function is
+ used instead.
+ """
+ method = 'visit_' + node.__class__.__name__
+ return getattr(self, method, None)
+
+ def visit(self, node):
+ """Visit a node."""
+ f = self.get_visitor(node)
+ if f is not None:
+ return f(node)
+ return self.generic_visit(node)
+
+ def generic_visit(self, node):
+ """Called if no explicit visitor function exists for a node."""
+ for field, value in iter_fields(node):
+ if isinstance(value, list):
+ for item in value:
+ if isinstance(item, AST):
+ self.visit(item)
+ elif isinstance(value, AST):
+ self.visit(value)
+
+
+class NodeTransformer(NodeVisitor):
+ """
+ Walks the abstract syntax tree and allows modifications of nodes.
+
+ The `NodeTransformer` will walk the AST and use the return value of the
+ visitor functions to replace or remove the old node. If the return
+ value of the visitor function is `None` the node will be removed
+ from the previous location otherwise it's replaced with the return
+ value. The return value may be the original node in which case no
+ replacement takes place.
+
+ Here an example transformer that rewrites all `foo` to `data['foo']`::
+
+ class RewriteName(NodeTransformer):
+
+ def visit_Name(self, node):
+ return copy_location(Subscript(
+ value=Name(id='data', ctx=Load()),
+ slice=Index(value=Str(s=node.id)),
+ ctx=node.ctx
+ ), node)
+
+ Keep in mind that if the node you're operating on has child nodes
+ you must either transform the child nodes yourself or call the generic
+ visit function for the node first.
+
+ Nodes that were part of a collection of statements (that applies to
+ all statement nodes) may also return a list of nodes rather than just
+ a single node.
+
+ Usually you use the transformer like this::
+
+ node = YourTransformer().visit(node)
+ """
+
+ def generic_visit(self, node):
+ for field, old_value in iter_fields(node):
+ old_value = getattr(node, field, None)
+ if isinstance(old_value, list):
+ new_values = []
+ for value in old_value:
+ if isinstance(value, AST):
+ value = self.visit(value)
+ if value is None:
+ continue
+ elif not isinstance(value, AST):
+ new_values.extend(value)
+ continue
+ new_values.append(value)
+ old_value[:] = new_values
+ elif isinstance(old_value, AST):
+ new_node = self.visit(old_value)
+ if new_node is None:
+ delattr(node, field)
+ else:
+ setattr(node, field, new_node)
+ return node
+
+
+class SourceGenerator(NodeVisitor):
+ """
+ This visitor is able to transform a well formed syntax tree into python
+ sourcecode. For more details have a look at the docstring of the
+ `node_to_source` function.
+ """
+
+ def __init__(self, indent_with):
+ self.result = []
+ self.indent_with = indent_with
+ self.indentation = 0
+ self.new_lines = 0
+
+ def write(self, x):
+ if self.new_lines:
+ if self.result:
+ self.result.append('\n' * self.new_lines)
+ self.result.append(self.indent_with * self.indentation)
+ self.new_lines = 0
+ self.result.append(x)
+
+ def newline(self, n=1):
+ self.new_lines = max(self.new_lines, n)
+
+ def body(self, statements):
+ self.new_line = True
+ self.indentation += 1
+ for stmt in statements:
+ self.visit(stmt)
+ self.indentation -= 1
+
+ def body_or_else(self, node):
+ self.body(node.body)
+ if node.orelse:
+ self.newline()
+ self.write('else:')
+ self.body(node.orelse)
+
+ def signature(self, node):
+ want_comma = []
+ def write_comma():
+ if want_comma:
+ self.write(', ')
+ else:
+ want_comma.append(True)
+
+ padding = [None] * (len(node.args) - len(node.defaults))
+ for arg, default in zip(node.args, padding + node.defaults):
+ write_comma()
+ self.visit(arg)
+ if default is not None:
+ self.write('=')
+ self.visit(default)
+ if node.vararg is not None:
+ write_comma()
+ self.write('*' + node.vararg)
+ if node.kwarg is not None:
+ write_comma()
+ self.write('**' + node.kwarg)
+
+ def decorators(self, node):
+ for decorator in node.decorator_list:
+ self.newline()
+ self.write('@')
+ self.visit(decorator)
+
+ # Statements
+
+ def visit_Assign(self, node):
+ self.newline()
+ for idx, target in enumerate(node.targets):
+ if idx:
+ self.write(', ')
+ self.visit(target)
+ self.write(' = ')
+ self.visit(node.value)
+
+ def visit_AugAssign(self, node):
+ self.newline()
+ self.visit(node.target)
+ self.write(BINOP_SYMBOLS[type(node.op)] + '=')
+ self.visit(node.value)
+
+ def visit_ImportFrom(self, node):
+ self.newline()
+ self.write('from %s%s import ' % ('.' * node.level, node.module))
+ for idx, item in enumerate(node.names):
+ if idx:
+ self.write(', ')
+ self.write(item)
+
+ def visit_Import(self, node):
+ self.newline()
+ for item in node.names:
+ self.write('import ')
+ self.visit(item)
+
+ def visit_Expr(self, node):
+ self.newline()
+ self.generic_visit(node)
+
+ def visit_FunctionDef(self, node):
+ self.newline(n=2)
+ self.decorators(node)
+ self.newline()
+ self.write('def %s(' % node.name)
+ self.signature(node.args)
+ self.write('):')
+ self.body(node.body)
+
+ def visit_ClassDef(self, node):
+ have_args = []
+ def paren_or_comma():
+ if have_args:
+ self.write(', ')
+ else:
+ have_args.append(True)
+ self.write('(')
+
+ self.newline(n=3)
+ self.decorators(node)
+ self.newline()
+ self.write('class %s' % node.name)
+ for base in node.bases:
+ paren_or_comma()
+ self.visit(base)
+ # XXX: the if here is used to keep this module compatible
+ # with python 2.6.
+ if hasattr(node, 'keywords'):
+ for keyword in node.keywords:
+ paren_or_comma()
+ self.write(keyword.arg + '=')
+ self.visit(keyword.value)
+ if node.starargs is not None:
+ paren_or_comma()
+ self.write('*')
+ self.visit(node.starargs)
+ if node.kwargs is not None:
+ paren_or_comma()
+ self.write('**')
+ self.visit(node.kwargs)
+ self.write(have_args and '):' or ':')
+ self.body(node.body)
+
+ def visit_If(self, node):
+ self.newline()
+ self.write('if ')
+ self.visit(node.test)
+ self.write(':')
+ self.body(node.body)
+ while True:
+ else_ = node.orelse
+ if len(else_) == 1 and isinstance(else_[0], If):
+ node = else_[0]
+ self.newline()
+ self.write('elif ')
+ self.visit(node.test)
+ self.write(':')
+ self.body(node.body)
+ else:
+ self.newline()
+ self.write('else:')
+ self.body(else_)
+ break
+
+ def visit_For(self, node):
+ self.newline()
+ self.write('for ')
+ self.visit(node.target)
+ self.write(' in ')
+ self.visit(node.iter)
+ self.write(':')
+ self.body_or_else(node)
+
+ def visit_While(self, node):
+ self.newline()
+ self.write('while ')
+ self.visit(node.test)
+ self.write(':')
+ self.body_or_else(node)
+
+ def visit_With(self, node):
+ self.newline()
+ self.write('with ')
+ self.visit(node.context_expr)
+ if node.optional_vars is not None:
+ self.write(' as ')
+ self.visit(node.optional_vars)
+ self.write(':')
+ self.body(node.body)
+
+ def visit_Pass(self, node):
+ self.newline()
+ self.write('pass')
+
+ def visit_Print(self, node):
+ # XXX: python 2.6 only
+ self.newline()
+ self.write('print ')
+ want_comma = False
+ if node.dest is not None:
+ self.write(' >> ')
+ self.visit(node.dest)
+ want_comma = True
+ for value in node.values:
+ if want_comma:
+ self.write(', ')
+ self.visit(value)
+ want_comma = True
+ if not node.nl:
+ self.write(',')
+
+ def visit_Delete(self, node):
+ self.newline()
+ self.write('del ')
+ for idx, target in enumerate(node):
+ if idx:
+ self.write(', ')
+ self.visit(target)
+
+ def visit_TryExcept(self, node):
+ self.newline()
+ self.write('try:')
+ self.body(node.body)
+ for handler in node.handlers:
+ self.visit(handler)
+
+ def visit_TryFinally(self, node):
+ self.newline()
+ self.write('try:')
+ self.body(node.body)
+ self.newline()
+ self.write('finally:')
+ self.body(node.finalbody)
+
+ def visit_Global(self, node):
+ self.newline()
+ self.write('global ' + ', '.join(node.names))
+
+ def visit_Nonlocal(self, node):
+ self.newline()
+ self.write('nonlocal ' + ', '.join(node.names))
+
+ def visit_Return(self, node):
+ self.newline()
+ self.write('return ')
+ self.visit(node.value)
+
+ def visit_Break(self, node):
+ self.newline()
+ self.write('break')
+
+ def visit_Continue(self, node):
+ self.newline()
+ self.write('continue')
+
+ def visit_Raise(self, node):
+ # XXX: Python 2.6 / 3.0 compatibility
+ self.newline()
+ self.write('raise')
+ if hasattr(node, 'exc') and node.exc is not None:
+ self.write(' ')
+ self.visit(node.exc)
+ if node.cause is not None:
+ self.write(' from ')
+ self.visit(node.cause)
+ elif hasattr(node, 'type') and node.type is not None:
+ self.visit(node.type)
+ if node.inst is not None:
+ self.write(', ')
+ self.visit(node.inst)
+ if node.tback is not None:
+ self.write(', ')
+ self.visit(node.tback)
+
+ # Expressions
+
+ def visit_Attribute(self, node):
+ self.visit(node.value)
+ self.write('.' + node.attr)
+
+ def visit_Call(self, node):
+ want_comma = []
+ def write_comma():
+ if want_comma:
+ self.write(', ')
+ else:
+ want_comma.append(True)
+
+ self.visit(node.func)
+ self.write('(')
+ for arg in node.args:
+ write_comma()
+ self.visit(arg)
+ for keyword in node.keywords:
+ write_comma()
+ self.write(keyword.arg + '=')
+ self.visit(keyword.value)
+ if node.starargs is not None:
+ write_comma()
+ self.write('*')
+ self.visit(node.starargs)
+ if node.kwargs is not None:
+ write_comma()
+ self.write('**')
+ self.visit(node.kwargs)
+ self.write(')')
+
+ def visit_Name(self, node):
+ self.write(node.id)
+
+ def visit_Str(self, node):
+ self.write(repr(node.s))
+
+ def visit_Bytes(self, node):
+ self.write(repr(node.s))
+
+ def visit_Num(self, node):
+ self.write(repr(node.n))
+
+ def visit_Tuple(self, node):
+ self.write('(')
+ idx = -1
+ for idx, item in enumerate(node.elts):
+ if idx:
+ self.write(', ')
+ self.visit(item)
+ self.write(idx and ')' or ',)')
+
+ def sequence_visit(left, right):
+ def visit(self, node):
+ self.write(left)
+ for idx, item in enumerate(node.elts):
+ if idx:
+ self.write(', ')
+ self.visit(item)
+ self.write(right)
+ return visit
+
+ visit_List = sequence_visit('[', ']')
+ visit_Set = sequence_visit('{', '}')
+ del sequence_visit
+
+ def visit_Dict(self, node):
+ self.write('{')
+ for idx, (key, value) in enumerate(zip(node.keys, node.values)):
+ if idx:
+ self.write(', ')
+ self.visit(key)
+ self.write(': ')
+ self.visit(value)
+ self.write('}')
+
+ def visit_BinOp(self, node):
+ self.write('(')
+ self.visit(node.left)
+ self.write(' %s ' % BINOP_SYMBOLS[type(node.op)])
+ self.visit(node.right)
+ self.write(')')
+
+ def visit_BoolOp(self, node):
+ self.write('(')
+ for idx, value in enumerate(node.values):
+ if idx:
+ self.write(' %s ' % BOOLOP_SYMBOLS[type(node.op)])
+ self.visit(value)
+ self.write(')')
+
+ def visit_Compare(self, node):
+ self.write('(')
+ self.visit(node.left)
+ for op, right in zip(node.ops, node.comparators):
+ self.write(' %s ' % CMPOP_SYMBOLS[type(op)])
+ self.visit(right)
+ self.write(')')
+
+ def visit_UnaryOp(self, node):
+ self.write('(')
+ op = UNARYOP_SYMBOLS[type(node.op)]
+ self.write(op)
+ if op == 'not':
+ self.write(' ')
+ self.visit(node.operand)
+ self.write(')')
+
+ def visit_Subscript(self, node):
+ self.visit(node.value)
+ self.write('[')
+ self.visit(node.slice)
+ self.write(']')
+
+ def visit_Slice(self, node):
+ if node.lower is not None:
+ self.visit(node.lower)
+ self.write(':')
+ if node.upper is not None:
+ self.visit(node.upper)
+ if node.step is not None:
+ self.write(':')
+ if not (isinstance(node.step, Name) and node.step.id == 'None'):
+ self.visit(node.step)
+
+ def visit_ExtSlice(self, node):
+ for idx, item in node.dims:
+ if idx:
+ self.write(', ')
+ self.visit(item)
+
+ def visit_Yield(self, node):
+ self.write('yield ')
+ self.visit(node.value)
+
+ def visit_Lambda(self, node):
+ self.write('lambda ')
+ self.signature(node.args)
+ self.write(': ')
+ self.visit(node.body)
+
+ def visit_Ellipsis(self, node):
+ self.write('Ellipsis')
+
+ def generator_visit(left, right):
+ def visit(self, node):
+ self.write(left)
+ self.visit(node.elt)
+ for comprehension in node.generators:
+ self.visit(comprehension)
+ self.write(right)
+ return visit
+
+ visit_ListComp = generator_visit('[', ']')
+ visit_GeneratorExp = generator_visit('(', ')')
+ visit_SetComp = generator_visit('{', '}')
+ del generator_visit
+
+ def visit_DictComp(self, node):
+ self.write('{')
+ self.visit(node.key)
+ self.write(': ')
+ self.visit(node.value)
+ for comprehension in node.generators:
+ self.visit(comprehension)
+ self.write('}')
+
+ def visit_IfExp(self, node):
+ self.visit(node.body)
+ self.write(' if ')
+ self.visit(node.test)
+ self.write(' else ')
+ self.visit(node.orelse)
+
+ def visit_Starred(self, node):
+ self.write('*')
+ self.visit(node.value)
+
+ def visit_Repr(self, node):
+ # XXX: python 2.6 only
+ self.write('`')
+ self.visit(node.value)
+ self.write('`')
+
+ # Helper Nodes
+
+ def visit_alias(self, node):
+ self.write(node.name)
+ if node.asname is not None:
+ self.write(' as ' + node.asname)
+
+ def visit_comprehension(self, node):
+ self.write(' for ')
+ self.visit(node.target)
+ self.write(' in ')
+ self.visit(node.iter)
+ if node.ifs:
+ for if_ in node.ifs:
+ self.write(' if ')
+ self.visit(if_)
+
+ def visit_excepthandler(self, node):
+ self.newline()
+ self.write('except')
+ if node.type is not None:
+ self.write(' ')
+ self.visit(node.type)
+ if node.name is not None:
+ self.write(' as ')
+ self.visit(node.name)
+ self.write(':')
+ self.body(node.body)
diff --git a/mako/ast.py b/mako/ast.py
new file mode 100644
index 00000000..4365b0b1
--- /dev/null
+++ b/mako/ast.py
@@ -0,0 +1,143 @@
+# mako/ast.py
+# Copyright (C) 2006-2011 the Mako authors and contributors
+#
+# This module is part of Mako and is released under
+# the MIT License: http://www.opensource.org/licenses/mit-license.php
+
+"""utilities for analyzing expressions and blocks of Python
+code, as well as generating Python from AST nodes"""
+
+from mako import exceptions, pyparser, util
+import re
+
+class PythonCode(object):
+ """represents information about a string containing Python code"""
+ def __init__(self, code, **exception_kwargs):
+ self.code = code
+
+ # represents all identifiers which are assigned to at some point in the code
+ self.declared_identifiers = set()
+
+ # represents all identifiers which are referenced before their assignment, if any
+ self.undeclared_identifiers = set()
+
+ # note that an identifier can be in both the undeclared and declared lists.
+
+ # using AST to parse instead of using code.co_varnames,
+ # code.co_names has several advantages:
+ # - we can locate an identifier as "undeclared" even if
+ # its declared later in the same block of code
+ # - AST is less likely to break with version changes
+ # (for example, the behavior of co_names changed a little bit
+ # in python version 2.5)
+ if isinstance(code, basestring):
+ expr = pyparser.parse(code.lstrip(), "exec", **exception_kwargs)
+ else:
+ expr = code
+
+ f = pyparser.FindIdentifiers(self, **exception_kwargs)
+ f.visit(expr)
+
+class ArgumentList(object):
+ """parses a fragment of code as a comma-separated list of expressions"""
+ def __init__(self, code, **exception_kwargs):
+ self.codeargs = []
+ self.args = []
+ self.declared_identifiers = set()
+ self.undeclared_identifiers = set()
+ if isinstance(code, basestring):
+ if re.match(r"\S", code) and not re.match(r",\s*$", code):
+ # if theres text and no trailing comma, insure its parsed
+ # as a tuple by adding a trailing comma
+ code += ","
+ expr = pyparser.parse(code, "exec", **exception_kwargs)
+ else:
+ expr = code
+
+ f = pyparser.FindTuple(self, PythonCode, **exception_kwargs)
+ f.visit(expr)
+
+class PythonFragment(PythonCode):
+ """extends PythonCode to provide identifier lookups in partial control statements
+
+ e.g.
+ for x in 5:
+ elif y==9:
+ except (MyException, e):
+ etc.
+ """
+ def __init__(self, code, **exception_kwargs):
+ m = re.match(r'^(\w+)(?:\s+(.*?))?:\s*(#|$)', code.strip(), re.S)
+ if not m:
+ raise exceptions.CompileException(
+ "Fragment '%s' is not a partial control statement" %
+ code, **exception_kwargs)
+ if m.group(3):
+ code = code[:m.start(3)]
+ (keyword, expr) = m.group(1,2)
+ if keyword in ['for','if', 'while']:
+ code = code + "pass"
+ elif keyword == 'try':
+ code = code + "pass\nexcept:pass"
+ elif keyword == 'elif' or keyword == 'else':
+ code = "if False:pass\n" + code + "pass"
+ elif keyword == 'except':
+ code = "try:pass\n" + code + "pass"
+ else:
+ raise exceptions.CompileException(
+ "Unsupported control keyword: '%s'" %
+ keyword, **exception_kwargs)
+ super(PythonFragment, self).__init__(code, **exception_kwargs)
+
+
+class FunctionDecl(object):
+ """function declaration"""
+ def __init__(self, code, allow_kwargs=True, **exception_kwargs):
+ self.code = code
+ expr = pyparser.parse(code, "exec", **exception_kwargs)
+
+ f = pyparser.ParseFunc(self, **exception_kwargs)
+ f.visit(expr)
+ if not hasattr(self, 'funcname'):
+ raise exceptions.CompileException(
+ "Code '%s' is not a function declaration" % code,
+ **exception_kwargs)
+ if not allow_kwargs and self.kwargs:
+ raise exceptions.CompileException(
+ "'**%s' keyword argument not allowed here" %
+ self.argnames[-1], **exception_kwargs)
+
+ def get_argument_expressions(self, include_defaults=True):
+ """return the argument declarations of this FunctionDecl as a printable list."""
+
+ namedecls = []
+ defaults = [d for d in self.defaults]
+ kwargs = self.kwargs
+ varargs = self.varargs
+ argnames = [f for f in self.argnames]
+ argnames.reverse()
+ for arg in argnames:
+ default = None
+ if kwargs:
+ arg = "**" + arg
+ kwargs = False
+ elif varargs:
+ arg = "*" + arg
+ varargs = False
+ else:
+ default = len(defaults) and defaults.pop() or None
+ if include_defaults and default:
+ namedecls.insert(0, "%s=%s" %
+ (arg,
+ pyparser.ExpressionGenerator(default).value()
+ )
+ )
+ else:
+ namedecls.insert(0, arg)
+ return namedecls
+
+class FunctionArgs(FunctionDecl):
+ """the argument portion of a function declaration"""
+
+ def __init__(self, code, **kwargs):
+ super(FunctionArgs, self).__init__("def ANON(%s):pass" % code, **kwargs)
diff --git a/mako/cache.py b/mako/cache.py
new file mode 100644
index 00000000..ce73ae5c
--- /dev/null
+++ b/mako/cache.py
@@ -0,0 +1,124 @@
+# mako/cache.py
+# Copyright (C) 2006-2011 the Mako authors and contributors
+#
+# This module is part of Mako and is released under
+# the MIT License: http://www.opensource.org/licenses/mit-license.php
+
+from mako import exceptions
+
+cache = None
+
+class BeakerMissing(object):
+ def get_cache(self, name, **kwargs):
+ raise exceptions.RuntimeException("the Beaker package is required to use cache functionality.")
+
+class Cache(object):
+ """Represents a data content cache made available to the module
+ space of a :class:`.Template` object.
+
+ :class:`.Cache` is a wrapper on top of a Beaker CacheManager object.
+ This object in turn references any number of "containers", each of
+ which defines its own backend (i.e. file, memory, memcached, etc.)
+ independently of the rest.
+
+ """
+
+ def __init__(self, id, starttime):
+ self.id = id
+ self.starttime = starttime
+ self.def_regions = {}
+
+ def put(self, key, value, **kwargs):
+ """Place a value in the cache.
+
+ :param key: the value's key.
+ :param value: the value
+ :param \**kwargs: cache configuration arguments. The
+ backend is configured using these arguments upon first request.
+ Subsequent requests that use the same series of configuration
+ values will use that same backend.
+
+ """
+
+ defname = kwargs.pop('defname', None)
+ expiretime = kwargs.pop('expiretime', None)
+ createfunc = kwargs.pop('createfunc', None)
+
+ self._get_cache(defname, **kwargs).put_value(key, starttime=self.starttime, expiretime=expiretime)
+
+ def get(self, key, **kwargs):
+ """Retrieve a value from the cache.
+
+ :param key: the value's key.
+ :param \**kwargs: cache configuration arguments. The
+ backend is configured using these arguments upon first request.
+ Subsequent requests that use the same series of configuration
+ values will use that same backend.
+
+ """
+
+ defname = kwargs.pop('defname', None)
+ expiretime = kwargs.pop('expiretime', None)
+ createfunc = kwargs.pop('createfunc', None)
+
+ return self._get_cache(defname, **kwargs).get_value(key, starttime=self.starttime, expiretime=expiretime, createfunc=createfunc)
+
+ def invalidate(self, key, **kwargs):
+ """Invalidate a value in the cache.
+
+ :param key: the value's key.
+ :param \**kwargs: cache configuration arguments. The
+ backend is configured using these arguments upon first request.
+ Subsequent requests that use the same series of configuration
+ values will use that same backend.
+
+ """
+ defname = kwargs.pop('defname', None)
+ expiretime = kwargs.pop('expiretime', None)
+ createfunc = kwargs.pop('createfunc', None)
+
+ self._get_cache(defname, **kwargs).remove_value(key, starttime=self.starttime, expiretime=expiretime)
+
+ def invalidate_body(self):
+ """Invalidate the cached content of the "body" method for this template.
+
+ """
+ self.invalidate('render_body', defname='render_body')
+
+ def invalidate_def(self, name):
+ """Invalidate the cached content of a particular <%def> within this template."""
+
+ self.invalidate('render_%s' % name, defname='render_%s' % name)
+
+ def invalidate_closure(self, name):
+ """Invalidate a nested <%def> within this template.
+
+ Caching of nested defs is a blunt tool as there is no
+ management of scope - nested defs that use cache tags
+ need to have names unique of all other nested defs in the
+ template, else their content will be overwritten by
+ each other.
+
+ """
+
+ self.invalidate(name, defname=name)
+
+ def _get_cache(self, defname, type=None, **kw):
+ global cache
+ if not cache:
+ try:
+ from beaker import cache as beaker_cache
+ cache = beaker_cache.CacheManager()
+ except ImportError:
+ # keep a fake cache around so subsequent
+ # calls don't attempt to re-import
+ cache = BeakerMissing()
+
+ if type == 'memcached':
+ type = 'ext:memcached'
+ if not type:
+ (type, kw) = self.def_regions.get(defname, ('memory', {}))
+ else:
+ self.def_regions[defname] = (type, kw)
+ return cache.get_cache(self.id, type=type, **kw)
+
\ No newline at end of file
diff --git a/mako/codegen.py b/mako/codegen.py
new file mode 100644
index 00000000..53691807
--- /dev/null
+++ b/mako/codegen.py
@@ -0,0 +1,1051 @@
+# mako/codegen.py
+# Copyright (C) 2006-2011 the Mako authors and contributors
+#
+# This module is part of Mako and is released under
+# the MIT License: http://www.opensource.org/licenses/mit-license.php
+
+"""provides functionality for rendering a parsetree constructing into module source code."""
+
+import time
+import re
+from mako.pygen import PythonPrinter
+from mako import util, ast, parsetree, filters, exceptions
+
+MAGIC_NUMBER = 6
+
+def compile(node,
+ uri,
+ filename=None,
+ default_filters=None,
+ buffer_filters=None,
+ imports=None,
+ source_encoding=None,
+ generate_magic_comment=True,
+ disable_unicode=False,
+ strict_undefined=False):
+
+ """Generate module source code given a parsetree node,
+ uri, and optional source filename"""
+
+ # if on Py2K, push the "source_encoding" string to be
+ # a bytestring itself, as we will be embedding it into
+ # the generated source and we don't want to coerce the
+ # result into a unicode object, in "disable_unicode" mode
+ if not util.py3k and isinstance(source_encoding, unicode):
+ source_encoding = source_encoding.encode(source_encoding)
+
+
+ buf = util.FastEncodingBuffer()
+
+ printer = PythonPrinter(buf)
+ _GenerateRenderMethod(printer,
+ _CompileContext(uri,
+ filename,
+ default_filters,
+ buffer_filters,
+ imports,
+ source_encoding,
+ generate_magic_comment,
+ disable_unicode,
+ strict_undefined),
+ node)
+ return buf.getvalue()
+
+class _CompileContext(object):
+ def __init__(self,
+ uri,
+ filename,
+ default_filters,
+ buffer_filters,
+ imports,
+ source_encoding,
+ generate_magic_comment,
+ disable_unicode,
+ strict_undefined):
+ self.uri = uri
+ self.filename = filename
+ self.default_filters = default_filters
+ self.buffer_filters = buffer_filters
+ self.imports = imports
+ self.source_encoding = source_encoding
+ self.generate_magic_comment = generate_magic_comment
+ self.disable_unicode = disable_unicode
+ self.strict_undefined = strict_undefined
+
+class _GenerateRenderMethod(object):
+ """A template visitor object which generates the
+ full module source for a template.
+
+ """
+ def __init__(self, printer, compiler, node):
+ self.printer = printer
+ self.last_source_line = -1
+ self.compiler = compiler
+ self.node = node
+ self.identifier_stack = [None]
+
+ self.in_def = isinstance(node, (parsetree.DefTag, parsetree.BlockTag))
+
+ if self.in_def:
+ name = "render_%s" % node.funcname
+ args = node.get_argument_expressions()
+ filtered = len(node.filter_args.args) > 0
+ buffered = eval(node.attributes.get('buffered', 'False'))
+ cached = eval(node.attributes.get('cached', 'False'))
+ defs = None
+ pagetag = None
+ if node.is_block and not node.is_anonymous:
+ args += ['**pageargs']
+ else:
+ defs = self.write_toplevel()
+ pagetag = self.compiler.pagetag
+ name = "render_body"
+ if pagetag is not None:
+ args = pagetag.body_decl.get_argument_expressions()
+ if not pagetag.body_decl.kwargs:
+ args += ['**pageargs']
+ cached = eval(pagetag.attributes.get('cached', 'False'))
+ else:
+ args = ['**pageargs']
+ cached = False
+ buffered = filtered = False
+ if args is None:
+ args = ['context']
+ else:
+ args = [a for a in ['context'] + args]
+
+ self.write_render_callable(
+ pagetag or node,
+ name, args,
+ buffered, filtered, cached)
+
+ if defs is not None:
+ for node in defs:
+ _GenerateRenderMethod(printer, compiler, node)
+
+ @property
+ def identifiers(self):
+ return self.identifier_stack[-1]
+
+ def write_toplevel(self):
+ """Traverse a template structure for module-level directives and
+ generate the start of module-level code.
+
+ """
+ inherit = []
+ namespaces = {}
+ module_code = []
+ encoding =[None]
+
+ self.compiler.pagetag = None
+
+ class FindTopLevel(object):
+ def visitInheritTag(s, node):
+ inherit.append(node)
+ def visitNamespaceTag(s, node):
+ namespaces[node.name] = node
+ def visitPageTag(s, node):
+ self.compiler.pagetag = node
+ def visitCode(s, node):
+ if node.ismodule:
+ module_code.append(node)
+
+ f = FindTopLevel()
+ for n in self.node.nodes:
+ n.accept_visitor(f)
+
+ self.compiler.namespaces = namespaces
+
+ module_ident = set()
+ for n in module_code:
+ module_ident = module_ident.union(n.declared_identifiers())
+
+ module_identifiers = _Identifiers()
+ module_identifiers.declared = module_ident
+
+ # module-level names, python code
+ if self.compiler.generate_magic_comment and \
+ self.compiler.source_encoding:
+ self.printer.writeline("# -*- encoding:%s -*-" %
+ self.compiler.source_encoding)
+
+ self.printer.writeline("from mako import runtime, filters, cache")
+ self.printer.writeline("UNDEFINED = runtime.UNDEFINED")
+ self.printer.writeline("__M_dict_builtin = dict")
+ self.printer.writeline("__M_locals_builtin = locals")
+ self.printer.writeline("_magic_number = %r" % MAGIC_NUMBER)
+ self.printer.writeline("_modified_time = %r" % time.time())
+ self.printer.writeline(
+ "_template_filename=%r" % self.compiler.filename)
+ self.printer.writeline("_template_uri=%r" % self.compiler.uri)
+ self.printer.writeline(
+ "_template_cache=cache.Cache(__name__, _modified_time)")
+ self.printer.writeline(
+ "_source_encoding=%r" % self.compiler.source_encoding)
+ if self.compiler.imports:
+ buf = ''
+ for imp in self.compiler.imports:
+ buf += imp + "\n"
+ self.printer.writeline(imp)
+ impcode = ast.PythonCode(
+ buf,
+ source='', lineno=0,
+ pos=0,
+ filename='template defined imports')
+ else:
+ impcode = None
+
+ main_identifiers = module_identifiers.branch(self.node)
+ module_identifiers.topleveldefs = \
+ module_identifiers.topleveldefs.\
+ union(main_identifiers.topleveldefs)
+ module_identifiers.declared.add("UNDEFINED")
+ if impcode:
+ module_identifiers.declared.update(impcode.declared_identifiers)
+
+ self.compiler.identifiers = module_identifiers
+ self.printer.writeline("_exports = %r" %
+ [n.name for n in
+ main_identifiers.topleveldefs.values()]
+ )
+ self.printer.write("\n\n")
+
+ if len(module_code):
+ self.write_module_code(module_code)
+
+ if len(inherit):
+ self.write_namespaces(namespaces)
+ self.write_inherit(inherit[-1])
+ elif len(namespaces):
+ self.write_namespaces(namespaces)
+
+ return main_identifiers.topleveldefs.values()
+
+ def write_render_callable(self, node, name, args, buffered, filtered, cached):
+ """write a top-level render callable.
+
+ this could be the main render() method or that of a top-level def."""
+
+ if self.in_def:
+ decorator = node.decorator
+ if decorator:
+ self.printer.writeline("@runtime._decorate_toplevel(%s)" % decorator)
+
+ self.printer.writelines(
+ "def %s(%s):" % (name, ','.join(args)),
+ "context.caller_stack._push_frame()",
+ "try:"
+ )
+ if buffered or filtered or cached:
+ self.printer.writeline("context._push_buffer()")
+
+ self.identifier_stack.append(self.compiler.identifiers.branch(self.node))
+ if (not self.in_def or self.node.is_block) and '**pageargs' in args:
+ self.identifier_stack[-1].argument_declared.add('pageargs')
+
+ if not self.in_def and (
+ len(self.identifiers.locally_assigned) > 0 or
+ len(self.identifiers.argument_declared) > 0
+ ):
+ self.printer.writeline("__M_locals = __M_dict_builtin(%s)" %
+ ','.join([
+ "%s=%s" % (x, x) for x in
+ self.identifiers.argument_declared
+ ]))
+
+ self.write_variable_declares(self.identifiers, toplevel=True)
+
+ for n in self.node.nodes:
+ n.accept_visitor(self)
+
+ self.write_def_finish(self.node, buffered, filtered, cached)
+ self.printer.writeline(None)
+ self.printer.write("\n\n")
+ if cached:
+ self.write_cache_decorator(
+ node, name,
+ args, buffered,
+ self.identifiers, toplevel=True)
+
+ def write_module_code(self, module_code):
+ """write module-level template code, i.e. that which
+ is enclosed in <%! %> tags in the template."""
+ for n in module_code:
+ self.write_source_comment(n)
+ self.printer.write_indented_block(n.text)
+
+ def write_inherit(self, node):
+ """write the module-level inheritance-determination callable."""
+
+ self.printer.writelines(
+ "def _mako_inherit(template, context):",
+ "_mako_generate_namespaces(context)",
+ "return runtime._inherit_from(context, %s, _template_uri)" %
+ (node.parsed_attributes['file']),
+ None
+ )
+
+ def write_namespaces(self, namespaces):
+ """write the module-level namespace-generating callable."""
+ self.printer.writelines(
+ "def _mako_get_namespace(context, name):",
+ "try:",
+ "return context.namespaces[(__name__, name)]",
+ "except KeyError:",
+ "_mako_generate_namespaces(context)",
+ "return context.namespaces[(__name__, name)]",
+ None,None
+ )
+ self.printer.writeline("def _mako_generate_namespaces(context):")
+
+
+ for node in namespaces.values():
+ if node.attributes.has_key('import'):
+ self.compiler.has_ns_imports = True
+ self.write_source_comment(node)
+ if len(node.nodes):
+ self.printer.writeline("def make_namespace():")
+ export = []
+ identifiers = self.compiler.identifiers.branch(node)
+ self.in_def = True
+ class NSDefVisitor(object):
+ def visitDefTag(s, node):
+ s.visitDefOrBase(node)
+
+ def visitBlockTag(s, node):
+ s.visitDefOrBase(node)
+
+ def visitDefOrBase(s, node):
+ if node.is_anonymous:
+ raise exceptions.CompileException(
+ "Can't put anonymous blocks inside <%namespace>",
+ **node.exception_kwargs
+ )
+ self.write_inline_def(node, identifiers, nested=False)
+ export.append(node.funcname)
+ vis = NSDefVisitor()
+ for n in node.nodes:
+ n.accept_visitor(vis)
+ self.printer.writeline("return [%s]" % (','.join(export)))
+ self.printer.writeline(None)
+ self.in_def = False
+ callable_name = "make_namespace()"
+ else:
+ callable_name = "None"
+
+ if 'file' in node.parsed_attributes:
+ self.printer.writeline(
+ "ns = runtime.TemplateNamespace(%r, context._clean_inheritance_tokens(),"
+ " templateuri=%s, callables=%s, calling_uri=_template_uri)" %
+ (
+ node.name,
+ node.parsed_attributes.get('file', 'None'),
+ callable_name,
+ )
+ )
+ elif 'module' in node.parsed_attributes:
+ self.printer.writeline(
+ "ns = runtime.ModuleNamespace(%r, context._clean_inheritance_tokens(),"
+ " callables=%s, calling_uri=_template_uri, module=%s)" %
+ (
+ node.name,
+ callable_name,
+ node.parsed_attributes.get('module', 'None')
+ )
+ )
+ else:
+ self.printer.writeline(
+ "ns = runtime.Namespace(%r, context._clean_inheritance_tokens(),"
+ " callables=%s, calling_uri=_template_uri)" %
+ (
+ node.name,
+ callable_name,
+ )
+ )
+ if eval(node.attributes.get('inheritable', "False")):
+ self.printer.writeline("context['self'].%s = ns" % (node.name))
+
+ self.printer.writeline("context.namespaces[(__name__, %s)] = ns" % repr(node.name))
+ self.printer.write("\n")
+ if not len(namespaces):
+ self.printer.writeline("pass")
+ self.printer.writeline(None)
+
+ def write_variable_declares(self, identifiers, toplevel=False, limit=None):
+ """write variable declarations at the top of a function.
+
+ the variable declarations are in the form of callable
+ definitions for defs and/or name lookup within the
+ function's context argument. the names declared are based
+ on the names that are referenced in the function body,
+ which don't otherwise have any explicit assignment
+ operation. names that are assigned within the body are
+ assumed to be locally-scoped variables and are not
+ separately declared.
+
+ for def callable definitions, if the def is a top-level
+ callable then a 'stub' callable is generated which wraps
+ the current Context into a closure. if the def is not
+ top-level, it is fully rendered as a local closure.
+
+ """
+ # collection of all defs available to us in this scope
+ comp_idents = dict([(c.funcname, c) for c in identifiers.defs])
+ to_write = set()
+
+ # write "context.get()" for all variables we are going to
+ # need that arent in the namespace yet
+ to_write = to_write.union(identifiers.undeclared)
+
+ # write closure functions for closures that we define
+ # right here
+ to_write = to_write.union([c.funcname for c in identifiers.closuredefs.values()])
+
+ # remove identifiers that are declared in the argument
+ # signature of the callable
+ to_write = to_write.difference(identifiers.argument_declared)
+
+ # remove identifiers that we are going to assign to.
+ # in this way we mimic Python's behavior,
+ # i.e. assignment to a variable within a block
+ # means that variable is now a "locally declared" var,
+ # which cannot be referenced beforehand.
+ to_write = to_write.difference(identifiers.locally_declared)
+
+ # if a limiting set was sent, constraint to those items in that list
+ # (this is used for the caching decorator)
+ if limit is not None:
+ to_write = to_write.intersection(limit)
+
+ if toplevel and getattr(self.compiler, 'has_ns_imports', False):
+ self.printer.writeline("_import_ns = {}")
+ self.compiler.has_imports = True
+ for ident, ns in self.compiler.namespaces.iteritems():
+ if ns.attributes.has_key('import'):
+ self.printer.writeline(
+ "_mako_get_namespace(context, %r)._populate(_import_ns, %r)" %
+ (
+ ident,
+ re.split(r'\s*,\s*', ns.attributes['import'])
+ ))
+
+ for ident in to_write:
+ if ident in comp_idents:
+ comp = comp_idents[ident]
+ if comp.is_block:
+ if not comp.is_anonymous:
+ self.write_def_decl(comp, identifiers)
+ else:
+ self.write_inline_def(comp, identifiers, nested=True)
+ else:
+ if comp.is_root():
+ self.write_def_decl(comp, identifiers)
+ else:
+ self.write_inline_def(comp, identifiers, nested=True)
+
+ elif ident in self.compiler.namespaces:
+ self.printer.writeline(
+ "%s = _mako_get_namespace(context, %r)" %
+ (ident, ident)
+ )
+ else:
+ if getattr(self.compiler, 'has_ns_imports', False):
+ if self.compiler.strict_undefined:
+ self.printer.writelines(
+ "%s = _import_ns.get(%r, UNDEFINED)" %
+ (ident, ident),
+ "if %s is UNDEFINED:" % ident,
+ "try:",
+ "%s = context[%r]" % (ident, ident),
+ "except KeyError:",
+ "raise NameError(\"'%s' is not defined\")" %
+ ident,
+ None, None
+ )
+ else:
+ self.printer.writeline(
+ "%s = _import_ns.get(%r, context.get(%r, UNDEFINED))" %
+ (ident, ident, ident))
+ else:
+ if self.compiler.strict_undefined:
+ self.printer.writelines(
+ "try:",
+ "%s = context[%r]" % (ident, ident),
+ "except KeyError:",
+ "raise NameError(\"'%s' is not defined\")" %
+ ident,
+ None
+ )
+ else:
+ self.printer.writeline(
+ "%s = context.get(%r, UNDEFINED)" % (ident, ident)
+ )
+
+ self.printer.writeline("__M_writer = context.writer()")
+
+ def write_source_comment(self, node):
+ """write a source comment containing the line number of the corresponding template line."""
+ if self.last_source_line != node.lineno:
+ self.printer.writeline("# SOURCE LINE %d" % node.lineno)
+ self.last_source_line = node.lineno
+
+ def write_def_decl(self, node, identifiers):
+ """write a locally-available callable referencing a top-level def"""
+ funcname = node.funcname
+ namedecls = node.get_argument_expressions()
+ nameargs = node.get_argument_expressions(include_defaults=False)
+
+ if not self.in_def and (
+ len(self.identifiers.locally_assigned) > 0 or
+ len(self.identifiers.argument_declared) > 0):
+ nameargs.insert(0, 'context.locals_(__M_locals)')
+ else:
+ nameargs.insert(0, 'context')
+ self.printer.writeline("def %s(%s):" % (funcname, ",".join(namedecls)))
+ self.printer.writeline("return render_%s(%s)" % (funcname, ",".join(nameargs)))
+ self.printer.writeline(None)
+
+ def write_inline_def(self, node, identifiers, nested):
+ """write a locally-available def callable inside an enclosing def."""
+
+ namedecls = node.get_argument_expressions()
+
+ decorator = node.decorator
+ if decorator:
+ self.printer.writeline("@runtime._decorate_inline(context, %s)" % decorator)
+ self.printer.writeline("def %s(%s):" % (node.funcname, ",".join(namedecls)))
+ filtered = len(node.filter_args.args) > 0
+ buffered = eval(node.attributes.get('buffered', 'False'))
+ cached = eval(node.attributes.get('cached', 'False'))
+ self.printer.writelines(
+ "context.caller_stack._push_frame()",
+ "try:"
+ )
+ if buffered or filtered or cached:
+ self.printer.writelines(
+ "context._push_buffer()",
+ )
+
+ identifiers = identifiers.branch(node, nested=nested)
+
+ self.write_variable_declares(identifiers)
+
+ self.identifier_stack.append(identifiers)
+ for n in node.nodes:
+ n.accept_visitor(self)
+ self.identifier_stack.pop()
+
+ self.write_def_finish(node, buffered, filtered, cached)
+ self.printer.writeline(None)
+ if cached:
+ self.write_cache_decorator(node, node.funcname,
+ namedecls, False, identifiers,
+ inline=True, toplevel=False)
+
+ def write_def_finish(self, node, buffered, filtered, cached, callstack=True):
+ """write the end section of a rendering function, either outermost or inline.
+
+ this takes into account if the rendering function was filtered, buffered, etc.
+ and closes the corresponding try: block if any, and writes code to retrieve
+ captured content, apply filters, send proper return value."""
+
+ if not buffered and not cached and not filtered:
+ self.printer.writeline("return ''")
+ if callstack:
+ self.printer.writelines(
+ "finally:",
+ "context.caller_stack._pop_frame()",
+ None
+ )
+
+ if buffered or filtered or cached:
+ if buffered or cached:
+ # in a caching scenario, don't try to get a writer
+ # from the context after popping; assume the caching
+ # implemenation might be using a context with no
+ # extra buffers
+ self.printer.writelines(
+ "finally:",
+ "__M_buf = context._pop_buffer()"
+ )
+ else:
+ self.printer.writelines(
+ "finally:",
+ "__M_buf, __M_writer = context._pop_buffer_and_writer()"
+ )
+
+ if callstack:
+ self.printer.writeline("context.caller_stack._pop_frame()")
+
+ s = "__M_buf.getvalue()"
+ if filtered:
+ s = self.create_filter_callable(node.filter_args.args, s, False)
+ self.printer.writeline(None)
+ if buffered and not cached:
+ s = self.create_filter_callable(self.compiler.buffer_filters, s, False)
+ if buffered or cached:
+ self.printer.writeline("return %s" % s)
+ else:
+ self.printer.writelines(
+ "__M_writer(%s)" % s,
+ "return ''"
+ )
+
+ def write_cache_decorator(self, node_or_pagetag, name,
+ args, buffered, identifiers,
+ inline=False, toplevel=False):
+ """write a post-function decorator to replace a rendering
+ callable with a cached version of itself."""
+
+ self.printer.writeline("__M_%s = %s" % (name, name))
+ cachekey = node_or_pagetag.parsed_attributes.get('cache_key', repr(name))
+ cacheargs = {}
+ for arg in (
+ ('cache_type', 'type'), ('cache_dir', 'data_dir'),
+ ('cache_timeout', 'expiretime'), ('cache_url', 'url')):
+ val = node_or_pagetag.parsed_attributes.get(arg[0], None)
+ if val is not None:
+ if arg[1] == 'expiretime':
+ cacheargs[arg[1]] = int(eval(val))
+ else:
+ cacheargs[arg[1]] = val
+ else:
+ if self.compiler.pagetag is not None:
+ val = self.compiler.pagetag.parsed_attributes.get(arg[0], None)
+ if val is not None:
+ if arg[1] == 'expiretime':
+ cacheargs[arg[1]] == int(eval(val))
+ else:
+ cacheargs[arg[1]] = val
+
+ self.printer.writeline("def %s(%s):" % (name, ','.join(args)))
+
+ # form "arg1, arg2, arg3=arg3, arg4=arg4", etc.
+ pass_args = [
+ '=' in a and "%s=%s" % ((a.split('=')[0],)*2) or a
+ for a in args
+ ]
+
+ self.write_variable_declares(
+ identifiers,
+ toplevel=toplevel,
+ limit=node_or_pagetag.undeclared_identifiers()
+ )
+ if buffered:
+ s = "context.get('local')."\
+ "get_cached(%s, defname=%r, %screatefunc=lambda:__M_%s(%s))" % \
+ (cachekey, name,
+ ''.join(["%s=%s, " % (k,v) for k, v in cacheargs.iteritems()]),
+ name, ','.join(pass_args))
+ # apply buffer_filters
+ s = self.create_filter_callable(self.compiler.buffer_filters, s, False)
+ self.printer.writelines("return " + s,None)
+ else:
+ self.printer.writelines(
+ "__M_writer(context.get('local')."
+ "get_cached(%s, defname=%r, %screatefunc=lambda:__M_%s(%s)))" %
+ (cachekey, name,
+ ''.join(["%s=%s, " % (k,v) for k, v in cacheargs.iteritems()]),
+ name, ','.join(pass_args)),
+ "return ''",
+ None
+ )
+
+ def create_filter_callable(self, args, target, is_expression):
+ """write a filter-applying expression based on the filters
+ present in the given filter names, adjusting for the global
+ 'default' filter aliases as needed."""
+
+ def locate_encode(name):
+ if re.match(r'decode\..+', name):
+ return "filters." + name
+ elif self.compiler.disable_unicode:
+ return filters.NON_UNICODE_ESCAPES.get(name, name)
+ else:
+ return filters.DEFAULT_ESCAPES.get(name, name)
+
+ if 'n' not in args:
+ if is_expression:
+ if self.compiler.pagetag:
+ args = self.compiler.pagetag.filter_args.args + args
+ if self.compiler.default_filters:
+ args = self.compiler.default_filters + args
+ for e in args:
+ # if filter given as a function, get just the identifier portion
+ if e == 'n':
+ continue
+ m = re.match(r'(.+?)(\(.*\))', e)
+ if m:
+ (ident, fargs) = m.group(1,2)
+ f = locate_encode(ident)
+ e = f + fargs
+ else:
+ x = e
+ e = locate_encode(e)
+ assert e is not None
+ target = "%s(%s)" % (e, target)
+ return target
+
+ def visitExpression(self, node):
+ self.write_source_comment(node)
+ if len(node.escapes) or \
+ (
+ self.compiler.pagetag is not None and
+ len(self.compiler.pagetag.filter_args.args)
+ ) or \
+ len(self.compiler.default_filters):
+
+ s = self.create_filter_callable(node.escapes_code.args, "%s" % node.text, True)
+ self.printer.writeline("__M_writer(%s)" % s)
+ else:
+ self.printer.writeline("__M_writer(%s)" % node.text)
+
+ def visitControlLine(self, node):
+ if node.isend:
+ if not node.get_children():
+ self.printer.writeline("pass")
+ self.printer.writeline(None)
+ else:
+ self.write_source_comment(node)
+ self.printer.writeline(node.text)
+
+ def visitText(self, node):
+ self.write_source_comment(node)
+ self.printer.writeline("__M_writer(%s)" % repr(node.content))
+
+ def visitTextTag(self, node):
+ filtered = len(node.filter_args.args) > 0
+ if filtered:
+ self.printer.writelines(
+ "__M_writer = context._push_writer()",
+ "try:",
+ )
+ for n in node.nodes:
+ n.accept_visitor(self)
+ if filtered:
+ self.printer.writelines(
+ "finally:",
+ "__M_buf, __M_writer = context._pop_buffer_and_writer()",
+ "__M_writer(%s)" %
+ self.create_filter_callable(
+ node.filter_args.args,
+ "__M_buf.getvalue()",
+ False),
+ None
+ )
+
+ def visitCode(self, node):
+ if not node.ismodule:
+ self.write_source_comment(node)
+ self.printer.write_indented_block(node.text)
+
+ if not self.in_def and len(self.identifiers.locally_assigned) > 0:
+ # if we are the "template" def, fudge locally
+ # declared/modified variables into the "__M_locals" dictionary,
+ # which is used for def calls within the same template,
+ # to simulate "enclosing scope"
+ self.printer.writeline('__M_locals_builtin_stored = __M_locals_builtin()')
+ self.printer.writeline(
+ '__M_locals.update(__M_dict_builtin([(__M_key,'
+ ' __M_locals_builtin_stored[__M_key]) for '
+ '__M_key in [%s] if __M_key in __M_locals_builtin_stored]))' %
+ ','.join([repr(x) for x in node.declared_identifiers()]))
+
+ def visitIncludeTag(self, node):
+ self.write_source_comment(node)
+ args = node.attributes.get('args')
+ if args:
+ self.printer.writeline(
+ "runtime._include_file(context, %s, _template_uri, %s)" %
+ (node.parsed_attributes['file'], args))
+ else:
+ self.printer.writeline(
+ "runtime._include_file(context, %s, _template_uri)" %
+ (node.parsed_attributes['file']))
+
+ def visitNamespaceTag(self, node):
+ pass
+
+ def visitDefTag(self, node):
+ pass
+
+ def visitBlockTag(self, node):
+ if node.is_anonymous:
+ self.printer.writeline("%s()" % node.funcname)
+ else:
+ nameargs = node.get_argument_expressions(include_defaults=False)
+ nameargs += ['**pageargs']
+ self.printer.writeline("if 'parent' not in context._data or "
+ "not hasattr(context._data['parent'], '%s'):"
+ % node.funcname)
+ self.printer.writeline("context['self'].%s(%s)" % (node.funcname, ",".join(nameargs)))
+ self.printer.writeline("\n")
+
+ def visitCallNamespaceTag(self, node):
+ # TODO: we can put namespace-specific checks here, such
+ # as ensure the given namespace will be imported,
+ # pre-import the namespace, etc.
+ self.visitCallTag(node)
+
+ def visitCallTag(self, node):
+ self.printer.writeline("def ccall(caller):")
+ export = ['body']
+ callable_identifiers = self.identifiers.branch(node, nested=True)
+ body_identifiers = callable_identifiers.branch(node, nested=False)
+ # we want the 'caller' passed to ccall to be used
+ # for the body() function, but for other non-body()
+ # <%def>s within <%call> we want the current caller
+ # off the call stack (if any)
+ body_identifiers.add_declared('caller')
+
+ self.identifier_stack.append(body_identifiers)
+ class DefVisitor(object):
+ def visitDefTag(s, node):
+ s.visitDefOrBase(node)
+
+ def visitBlockTag(s, node):
+ s.visitDefOrBase(node)
+
+ def visitDefOrBase(s, node):
+ self.write_inline_def(node, callable_identifiers, nested=False)
+ if not node.is_anonymous:
+ export.append(node.funcname)
+ # remove defs that are within the <%call> from the "closuredefs" defined
+ # in the body, so they dont render twice
+ if node.funcname in body_identifiers.closuredefs:
+ del body_identifiers.closuredefs[node.funcname]
+
+ vis = DefVisitor()
+ for n in node.nodes:
+ n.accept_visitor(vis)
+ self.identifier_stack.pop()
+
+ bodyargs = node.body_decl.get_argument_expressions()
+ self.printer.writeline("def body(%s):" % ','.join(bodyargs))
+
+ # TODO: figure out best way to specify
+ # buffering/nonbuffering (at call time would be better)
+ buffered = False
+ if buffered:
+ self.printer.writelines(
+ "context._push_buffer()",
+ "try:"
+ )
+ self.write_variable_declares(body_identifiers)
+ self.identifier_stack.append(body_identifiers)
+
+ for n in node.nodes:
+ n.accept_visitor(self)
+ self.identifier_stack.pop()
+
+ self.write_def_finish(node, buffered, False, False, callstack=False)
+ self.printer.writelines(
+ None,
+ "return [%s]" % (','.join(export)),
+ None
+ )
+
+ self.printer.writelines(
+ # get local reference to current caller, if any
+ "caller = context.caller_stack._get_caller()",
+ # push on caller for nested call
+ "context.caller_stack.nextcaller = "
+ "runtime.Namespace('caller', context, callables=ccall(caller))",
+ "try:")
+ self.write_source_comment(node)
+ self.printer.writelines(
+ "__M_writer(%s)" % self.create_filter_callable([], node.expression, True),
+ "finally:",
+ "context.caller_stack.nextcaller = None",
+ None
+ )
+
+class _Identifiers(object):
+ """tracks the status of identifier names as template code is rendered."""
+
+ def __init__(self, node=None, parent=None, nested=False):
+
+ if parent is not None:
+ # if we are the branch created in write_namespaces(),
+ # we don't share any context from the main body().
+ if isinstance(node, parsetree.NamespaceTag):
+ self.declared = set()
+ self.topleveldefs = util.SetLikeDict()
+ else:
+ # things that have already been declared
+ # in an enclosing namespace (i.e. names we can just use)
+ self.declared = set(parent.declared).\
+ union([c.name for c in parent.closuredefs.values()]).\
+ union(parent.locally_declared).\
+ union(parent.argument_declared)
+
+ # if these identifiers correspond to a "nested"
+ # scope, it means whatever the parent identifiers
+ # had as undeclared will have been declared by that parent,
+ # and therefore we have them in our scope.
+ if nested:
+ self.declared = self.declared.union(parent.undeclared)
+
+ # top level defs that are available
+ self.topleveldefs = util.SetLikeDict(**parent.topleveldefs)
+ else:
+ self.declared = set()
+ self.topleveldefs = util.SetLikeDict()
+
+ # things within this level that are referenced before they
+ # are declared (e.g. assigned to)
+ self.undeclared = set()
+
+ # things that are declared locally. some of these things
+ # could be in the "undeclared" list as well if they are
+ # referenced before declared
+ self.locally_declared = set()
+
+ # assignments made in explicit python blocks.
+ # these will be propagated to
+ # the context of local def calls.
+ self.locally_assigned = set()
+
+ # things that are declared in the argument
+ # signature of the def callable
+ self.argument_declared = set()
+
+ # closure defs that are defined in this level
+ self.closuredefs = util.SetLikeDict()
+
+ self.node = node
+
+ if node is not None:
+ node.accept_visitor(self)
+
+ def branch(self, node, **kwargs):
+ """create a new Identifiers for a new Node, with
+ this Identifiers as the parent."""
+
+ return _Identifiers(node, self, **kwargs)
+
+ @property
+ def defs(self):
+ return set(self.topleveldefs.union(self.closuredefs).values())
+
+ def __repr__(self):
+ return "Identifiers(declared=%r, locally_declared=%r, "\
+ "undeclared=%r, topleveldefs=%r, closuredefs=%r, argumentdeclared=%r)" %\
+ (
+ list(self.declared),
+ list(self.locally_declared),
+ list(self.undeclared),
+ [c.name for c in self.topleveldefs.values()],
+ [c.name for c in self.closuredefs.values()],
+ self.argument_declared)
+
+ def check_declared(self, node):
+ """update the state of this Identifiers with the undeclared
+ and declared identifiers of the given node."""
+
+ for ident in node.undeclared_identifiers():
+ if ident != 'context' and ident not in self.declared.union(self.locally_declared):
+ self.undeclared.add(ident)
+ for ident in node.declared_identifiers():
+ self.locally_declared.add(ident)
+
+ def add_declared(self, ident):
+ self.declared.add(ident)
+ if ident in self.undeclared:
+ self.undeclared.remove(ident)
+
+ def visitExpression(self, node):
+ self.check_declared(node)
+
+ def visitControlLine(self, node):
+ self.check_declared(node)
+
+ def visitCode(self, node):
+ if not node.ismodule:
+ self.check_declared(node)
+ self.locally_assigned = self.locally_assigned.union(node.declared_identifiers())
+
+ def visitNamespaceTag(self, node):
+ # only traverse into the sub-elements of a
+ # <%namespace> tag if we are the branch created in
+ # write_namespaces()
+ if self.node is node:
+ for n in node.nodes:
+ n.accept_visitor(self)
+
+ def _check_name_exists(self, collection, node):
+ existing = collection.get(node.funcname)
+ collection[node.funcname] = node
+ if existing is not None and \
+ existing is not node and \
+ (node.is_block or existing.is_block):
+ raise exceptions.CompileException(
+ "%%def or %%block named '%s' already "
+ "exists in this template." %
+ node.funcname, **node.exception_kwargs)
+
+ def visitDefTag(self, node):
+ if node.is_root() and not node.is_anonymous:
+ self._check_name_exists(self.topleveldefs, node)
+ elif node is not self.node:
+ self._check_name_exists(self.closuredefs, node)
+
+ for ident in node.undeclared_identifiers():
+ if ident != 'context' and ident not in self.declared.union(self.locally_declared):
+ self.undeclared.add(ident)
+
+ # visit defs only one level deep
+ if node is self.node:
+ for ident in node.declared_identifiers():
+ self.argument_declared.add(ident)
+ for n in node.nodes:
+ n.accept_visitor(self)
+
+ def visitBlockTag(self, node):
+ if node is not self.node and \
+ not node.is_anonymous:
+
+ if isinstance(self.node, parsetree.DefTag):
+ raise exceptions.CompileException(
+ "Named block '%s' not allowed inside of def '%s'"
+ % (node.name, self.node.name), **node.exception_kwargs)
+ elif isinstance(self.node, (parsetree.CallTag, parsetree.CallNamespaceTag)):
+ raise exceptions.CompileException(
+ "Named block '%s' not allowed inside of <%%call> tag"
+ % (node.name, ), **node.exception_kwargs)
+
+ if not node.is_anonymous:
+ self._check_name_exists(self.topleveldefs, node)
+ self.undeclared.add(node.funcname)
+ elif node is not self.node:
+ self._check_name_exists(self.closuredefs, node)
+ for ident in node.declared_identifiers():
+ self.argument_declared.add(ident)
+ for n in node.nodes:
+ n.accept_visitor(self)
+
+ def visitIncludeTag(self, node):
+ self.check_declared(node)
+
+ def visitPageTag(self, node):
+ for ident in node.declared_identifiers():
+ self.argument_declared.add(ident)
+ self.check_declared(node)
+
+ def visitCallNamespaceTag(self, node):
+ self.visitCallTag(node)
+
+ def visitCallTag(self, node):
+ if node is self.node:
+ for ident in node.undeclared_identifiers():
+ if ident != 'context' and ident not in self.declared.union(self.locally_declared):
+ self.undeclared.add(ident)
+ for ident in node.declared_identifiers():
+ self.argument_declared.add(ident)
+ for n in node.nodes:
+ n.accept_visitor(self)
+ else:
+ for ident in node.undeclared_identifiers():
+ if ident != 'context' and ident not in self.declared.union(self.locally_declared):
+ self.undeclared.add(ident)
+
diff --git a/mako/exceptions.py b/mako/exceptions.py
new file mode 100644
index 00000000..491d2af5
--- /dev/null
+++ b/mako/exceptions.py
@@ -0,0 +1,307 @@
+# mako/exceptions.py
+# Copyright (C) 2006-2011 the Mako authors and contributors
+#
+# This module is part of Mako and is released under
+# the MIT License: http://www.opensource.org/licenses/mit-license.php
+
+"""exception classes"""
+
+import traceback, sys, re
+from mako import util
+
+class MakoException(Exception):
+ pass
+
+class RuntimeException(MakoException):
+ pass
+
+def _format_filepos(lineno, pos, filename):
+ if filename is None:
+ return " at line: %d char: %d" % (lineno, pos)
+ else:
+ return " in file '%s' at line: %d char: %d" % (filename, lineno, pos)
+
+
+class CompileException(MakoException):
+ def __init__(self, message, source, lineno, pos, filename):
+ MakoException.__init__(self, message + _format_filepos(lineno, pos, filename))
+ self.lineno =lineno
+ self.pos = pos
+ self.filename = filename
+ self.source = source
+
+class SyntaxException(MakoException):
+ def __init__(self, message, source, lineno, pos, filename):
+ MakoException.__init__(self, message + _format_filepos(lineno, pos, filename))
+ self.lineno =lineno
+ self.pos = pos
+ self.filename = filename
+ self.source = source
+
+class UnsupportedError(MakoException):
+ """raised when a retired feature is used."""
+
+class TemplateLookupException(MakoException):
+ pass
+
+class TopLevelLookupException(TemplateLookupException):
+ pass
+
+class RichTraceback(object):
+ """Pulls the current exception from the sys traceback and extracts
+ Mako-specific template information.
+
+ See the usage examples in :ref:`handling_exceptions`.
+
+ """
+ def __init__(self, error=None, traceback=None):
+ self.source, self.lineno = "", 0
+
+ if error is None or traceback is None:
+ t, value, tback = sys.exc_info()
+
+ if error is None:
+ error = value or t
+
+ if traceback is None:
+ traceback = tback
+
+ self.error = error
+ self.records = self._init(traceback)
+
+ if isinstance(self.error, (CompileException, SyntaxException)):
+ import mako.template
+ self.source = self.error.source
+ self.lineno = self.error.lineno
+ self._has_source = True
+
+ self._init_message()
+
+ @property
+ def errorname(self):
+ return util.exception_name(self.error)
+
+ def _init_message(self):
+ """Find a unicode representation of self.error"""
+ try:
+ self.message = unicode(self.error)
+ except UnicodeError:
+ try:
+ self.message = str(self.error)
+ except UnicodeEncodeError:
+ # Fallback to args as neither unicode nor
+ # str(Exception(u'\xe6')) work in Python < 2.6
+ self.message = self.error.args[0]
+ if not isinstance(self.message, unicode):
+ self.message = unicode(self.message, 'ascii', 'replace')
+
+ def _get_reformatted_records(self, records):
+ for rec in records:
+ if rec[6] is not None:
+ yield (rec[4], rec[5], rec[2], rec[6])
+ else:
+ yield tuple(rec[0:4])
+
+ @property
+ def traceback(self):
+ """return a list of 4-tuple traceback records (i.e. normal python
+ format) with template-corresponding lines remapped to the originating
+ template.
+
+ """
+ return list(self._get_reformatted_records(self.records))
+
+ @property
+ def reverse_records(self):
+ return reversed(self.records)
+
+ @property
+ def reverse_traceback(self):
+ """return the same data as traceback, except in reverse order.
+ """
+
+ return list(self._get_reformatted_records(self.reverse_records))
+
+ def _init(self, trcback):
+ """format a traceback from sys.exc_info() into 7-item tuples,
+ containing the regular four traceback tuple items, plus the original
+ template filename, the line number adjusted relative to the template
+ source, and code line from that line number of the template."""
+
+ import mako.template
+ mods = {}
+ rawrecords = traceback.extract_tb(trcback)
+ new_trcback = []
+ for filename, lineno, function, line in rawrecords:
+ if not line:
+ line = ''
+ try:
+ (line_map, template_lines) = mods[filename]
+ except KeyError:
+ try:
+ info = mako.template._get_module_info(filename)
+ module_source = info.code
+ template_source = info.source
+ template_filename = info.template_filename or filename
+ except KeyError:
+ # A normal .py file (not a Template)
+ if not util.py3k:
+ try:
+ fp = open(filename, 'rb')
+ encoding = util.parse_encoding(fp)
+ fp.close()
+ except IOError:
+ encoding = None
+ if encoding:
+ line = line.decode(encoding)
+ else:
+ line = line.decode('ascii', 'replace')
+ new_trcback.append((filename, lineno, function, line,
+ None, None, None, None))
+ continue
+
+ template_ln = module_ln = 1
+ line_map = {}
+ for line in module_source.split("\n"):
+ match = re.match(r'\s*# SOURCE LINE (\d+)', line)
+ if match:
+ template_ln = int(match.group(1))
+ module_ln += 1
+ line_map[module_ln] = template_ln
+ template_lines = [line for line in
+ template_source.split("\n")]
+ mods[filename] = (line_map, template_lines)
+
+ template_ln = line_map[lineno]
+ if template_ln <= len(template_lines):
+ template_line = template_lines[template_ln - 1]
+ else:
+ template_line = None
+ new_trcback.append((filename, lineno, function,
+ line, template_filename, template_ln,
+ template_line, template_source))
+ if not self.source:
+ for l in range(len(new_trcback)-1, 0, -1):
+ if new_trcback[l][5]:
+ self.source = new_trcback[l][7]
+ self.lineno = new_trcback[l][5]
+ break
+ else:
+ if new_trcback:
+ try:
+ # A normal .py file (not a Template)
+ fp = open(new_trcback[-1][0], 'rb')
+ encoding = util.parse_encoding(fp)
+ fp.seek(0)
+ self.source = fp.read()
+ fp.close()
+ if encoding:
+ self.source = self.source.decode(encoding)
+ except IOError:
+ self.source = ''
+ self.lineno = new_trcback[-1][1]
+ return new_trcback
+
+
+def text_error_template(lookup=None):
+ """Provides a template that renders a stack trace in a similar format to
+ the Python interpreter, substituting source template filenames, line
+ numbers and code for that of the originating source template, as
+ applicable.
+
+ """
+ import mako.template
+ return mako.template.Template(r"""
+<%page args="error=None, traceback=None"/>
+<%!
+ from mako.exceptions import RichTraceback
+%>\
+<%
+ tback = RichTraceback(error=error, traceback=traceback)
+%>\
+Traceback (most recent call last):
+% for (filename, lineno, function, line) in tback.traceback:
+ File "${filename}", line ${lineno}, in ${function or '?'}
+ ${line | trim}
+% endfor
+${tback.errorname}: ${tback.message}
+""")
+
+def html_error_template():
+ """Provides a template that renders a stack trace in an HTML format,
+ providing an excerpt of code as well as substituting source template
+ filenames, line numbers and code for that of the originating source
+ template, as applicable.
+
+ The template's default encoding_errors value is 'htmlentityreplace'. the
+ template has two options. With the full option disabled, only a section of
+ an HTML document is returned. with the css option disabled, the default
+ stylesheet won't be included.
+
+ """
+ import mako.template
+ return mako.template.Template(r"""
+<%!
+ from mako.exceptions import RichTraceback
+%>
+<%page args="full=True, css=True, error=None, traceback=None"/>
+% if full:
+
+
+ Mako Runtime Error
+% endif
+% if css:
+
+% endif
+% if full:
+
+
+% endif
+
+Error !
+<%
+ tback = RichTraceback(error=error, traceback=traceback)
+ src = tback.source
+ line = tback.lineno
+ if src:
+ lines = src.split('\n')
+ else:
+ lines = None
+%>
+${tback.errorname}: ${tback.message}
+
+% if lines:
+
+
+% for index in range(max(0, line-4),min(len(lines), line+5)):
+ % if index + 1 == line:
+
${index + 1} ${lines[index] | h}
+ % else:
+
${index + 1} ${lines[index] | h}
+ % endif
+% endfor
+
+
+% for (filename, lineno, function, line) in tback.reverse_traceback:
+
${filename}, line ${lineno}:
+
${line | h}
+% endfor
+
+#
+# This module is part of Mako and is released under
+# the MIT License: http://www.opensource.org/licenses/mit-license.php
+
+"""adds autohandler functionality to Mako templates.
+
+requires that the TemplateLookup class is used with templates.
+
+usage:
+
+<%!
+ from mako.ext.autohandler import autohandler
+%>
+<%inherit file="${autohandler(template, context)}"/>
+
+
+or with custom autohandler filename:
+
+<%!
+ from mako.ext.autohandler import autohandler
+%>
+<%inherit file="${autohandler(template, context, name='somefilename')}"/>
+
+"""
+
+import posixpath, os, re
+
+def autohandler(template, context, name='autohandler'):
+ lookup = context.lookup
+ _template_uri = template.module._template_uri
+ if not lookup.filesystem_checks:
+ try:
+ return lookup._uri_cache[(autohandler, _template_uri, name)]
+ except KeyError:
+ pass
+
+ tokens = re.findall(r'([^/]+)', posixpath.dirname(_template_uri)) + [name]
+ while len(tokens):
+ path = '/' + '/'.join(tokens)
+ if path != _template_uri and _file_exists(lookup, path):
+ if not lookup.filesystem_checks:
+ return lookup._uri_cache.setdefault(
+ (autohandler, _template_uri, name), path)
+ else:
+ return path
+ if len(tokens) == 1:
+ break
+ tokens[-2:] = [name]
+
+ if not lookup.filesystem_checks:
+ return lookup._uri_cache.setdefault(
+ (autohandler, _template_uri, name), None)
+ else:
+ return None
+
+def _file_exists(lookup, path):
+ psub = re.sub(r'^/', '',path)
+ for d in lookup.directories:
+ if os.path.exists(d + '/' + psub):
+ return True
+ else:
+ return False
+
diff --git a/mako/ext/babelplugin.py b/mako/ext/babelplugin.py
new file mode 100644
index 00000000..6b7c1d35
--- /dev/null
+++ b/mako/ext/babelplugin.py
@@ -0,0 +1,129 @@
+# ext/babelplugin.py
+# Copyright (C) 2006-2011 the Mako authors and contributors
+#
+# This module is part of Mako and is released under
+# the MIT License: http://www.opensource.org/licenses/mit-license.php
+
+"""gettext message extraction via Babel: http://babel.edgewall.org/"""
+from StringIO import StringIO
+
+from babel.messages.extract import extract_python
+
+from mako import lexer, parsetree
+
+def extract(fileobj, keywords, comment_tags, options):
+ """Extract messages from Mako templates.
+
+ :param fileobj: the file-like object the messages should be extracted from
+ :param keywords: a list of keywords (i.e. function names) that should be
+ recognized as translation functions
+ :param comment_tags: a list of translator tags to search for and include
+ in the results
+ :param options: a dictionary of additional options (optional)
+ :return: an iterator over ``(lineno, funcname, message, comments)`` tuples
+ :rtype: ``iterator``
+ """
+ encoding = options.get('input_encoding', options.get('encoding', None))
+
+ template_node = lexer.Lexer(fileobj.read(),
+ input_encoding=encoding).parse()
+ for extracted in extract_nodes(template_node.get_children(),
+ keywords, comment_tags, options):
+ yield extracted
+
+def extract_nodes(nodes, keywords, comment_tags, options):
+ """Extract messages from Mako's lexer node objects
+
+ :param nodes: an iterable of Mako parsetree.Node objects to extract from
+ :param keywords: a list of keywords (i.e. function names) that should be
+ recognized as translation functions
+ :param comment_tags: a list of translator tags to search for and include
+ in the results
+ :param options: a dictionary of additional options (optional)
+ :return: an iterator over ``(lineno, funcname, message, comments)`` tuples
+ :rtype: ``iterator``
+ """
+ translator_comments = []
+ in_translator_comments = False
+
+ for node in nodes:
+ child_nodes = None
+ if in_translator_comments and isinstance(node, parsetree.Text) and \
+ not node.content.strip():
+ # Ignore whitespace within translator comments
+ continue
+
+ if isinstance(node, parsetree.Comment):
+ value = node.text.strip()
+ if in_translator_comments:
+ translator_comments.extend(_split_comment(node.lineno, value))
+ continue
+ for comment_tag in comment_tags:
+ if value.startswith(comment_tag):
+ in_translator_comments = True
+ translator_comments.extend(_split_comment(node.lineno,
+ value))
+ continue
+
+ if isinstance(node, parsetree.DefTag):
+ code = node.function_decl.code
+ child_nodes = node.nodes
+ elif isinstance(node, parsetree.CallTag):
+ code = node.code.code
+ child_nodes = node.nodes
+ elif isinstance(node, parsetree.PageTag):
+ code = node.body_decl.code
+ elif isinstance(node, parsetree.CallNamespaceTag):
+ attribs = ', '.join(['%s=%s' % (key, val)
+ for key, val in node.attributes.iteritems()])
+ code = '{%s}' % attribs
+ child_nodes = node.nodes
+ elif isinstance(node, parsetree.ControlLine):
+ if node.isend:
+ translator_comments = []
+ in_translator_comments = False
+ continue
+ code = node.text
+ elif isinstance(node, parsetree.Code):
+ # <% and <%! blocks would provide their own translator comments
+ translator_comments = []
+ in_translator_comments = False
+
+ code = node.code.code
+ elif isinstance(node, parsetree.Expression):
+ code = node.code.code
+ else:
+ translator_comments = []
+ in_translator_comments = False
+ continue
+
+ # Comments don't apply unless they immediately preceed the message
+ if translator_comments and \
+ translator_comments[-1][0] < node.lineno - 1:
+ translator_comments = []
+ else:
+ translator_comments = \
+ [comment[1] for comment in translator_comments]
+
+ if isinstance(code, unicode):
+ code = code.encode('ascii', 'backslashreplace')
+ code = StringIO(code)
+ for lineno, funcname, messages, python_translator_comments \
+ in extract_python(code, keywords, comment_tags, options):
+ yield (node.lineno + (lineno - 1), funcname, messages,
+ translator_comments + python_translator_comments)
+
+ translator_comments = []
+ in_translator_comments = False
+
+ if child_nodes:
+ for extracted in extract_nodes(child_nodes, keywords, comment_tags,
+ options):
+ yield extracted
+
+
+def _split_comment(lineno, comment):
+ """Return the multiline comment at lineno split into a list of comment line
+ numbers and the accompanying comment line"""
+ return [(lineno + index, line) for index, line in
+ enumerate(comment.splitlines())]
diff --git a/mako/ext/preprocessors.py b/mako/ext/preprocessors.py
new file mode 100644
index 00000000..2c0d9935
--- /dev/null
+++ b/mako/ext/preprocessors.py
@@ -0,0 +1,20 @@
+# ext/preprocessors.py
+# Copyright (C) 2006-2011 the Mako authors and contributors
+#
+# This module is part of Mako and is released under
+# the MIT License: http://www.opensource.org/licenses/mit-license.php
+
+"""preprocessing functions, used with the 'preprocessor'
+argument on Template, TemplateLookup"""
+
+import re
+
+def convert_comments(text):
+ """preprocess old style comments.
+
+ example:
+
+ from mako.ext.preprocessors import convert_comments
+ t = Template(..., preprocessor=preprocess_comments)"""
+ return re.sub(r'(?<=\n)\s*#[^#]', "##", text)
+
diff --git a/mako/ext/pygmentplugin.py b/mako/ext/pygmentplugin.py
new file mode 100644
index 00000000..0ce57c47
--- /dev/null
+++ b/mako/ext/pygmentplugin.py
@@ -0,0 +1,107 @@
+# ext/pygmentplugin.py
+# Copyright (C) 2006-2011 the Mako authors and contributors
+#
+# This module is part of Mako and is released under
+# the MIT License: http://www.opensource.org/licenses/mit-license.php
+
+import re
+try:
+ set
+except NameError:
+ from sets import Set as set
+
+from pygments.lexers.web import \
+ HtmlLexer, XmlLexer, JavascriptLexer, CssLexer
+from pygments.lexers.agile import PythonLexer
+from pygments.lexer import Lexer, DelegatingLexer, RegexLexer, bygroups, \
+ include, using, this
+from pygments.token import Error, Punctuation, \
+ Text, Comment, Operator, Keyword, Name, String, Number, Other, Literal
+from pygments.util import html_doctype_matches, looks_like_xml
+
+class MakoLexer(RegexLexer):
+ name = 'Mako'
+ aliases = ['mako']
+ filenames = ['*.mao']
+
+ tokens = {
+ 'root': [
+ (r'(\s*)(\%)(\s*end(?:\w+))(\n|\Z)',
+ bygroups(Text, Comment.Preproc, Keyword, Other)),
+ (r'(\s*)(\%(?!%))([^\n]*)(\n|\Z)',
+ bygroups(Text, Comment.Preproc, using(PythonLexer), Other)),
+ (r'(\s*)(##[^\n]*)(\n|\Z)',
+ bygroups(Text, Comment.Preproc, Other)),
+ (r'''(?s)<%doc>.*?''', Comment.Preproc),
+ (r'(<%)([\w\.\:]+)', bygroups(Comment.Preproc, Name.Builtin), 'tag'),
+ (r'()', bygroups(Comment.Preproc, Name.Builtin, Comment.Preproc)),
+ (r'<%(?=([\w\.\:]+))', Comment.Preproc, 'ondeftags'),
+ (r'(<%(?:!?))(.*?)(%>)(?s)', bygroups(Comment.Preproc, using(PythonLexer), Comment.Preproc)),
+ (r'(\$\{)(.*?)(\})',
+ bygroups(Comment.Preproc, using(PythonLexer), Comment.Preproc)),
+ (r'''(?sx)
+ (.+?) # anything, followed by:
+ (?:
+ (?<=\n)(?=%(?!%)|\#\#) | # an eval or comment line
+ (?=\#\*) | # multiline comment
+ (?=', Comment.Preproc, '#pop'),
+ (r'\s+', Text),
+ ],
+ 'attr': [
+ ('".*?"', String, '#pop'),
+ ("'.*?'", String, '#pop'),
+ (r'[^\s>]+', String, '#pop'),
+ ],
+ }
+
+
+class MakoHtmlLexer(DelegatingLexer):
+ name = 'HTML+Mako'
+ aliases = ['html+mako']
+
+ def __init__(self, **options):
+ super(MakoHtmlLexer, self).__init__(HtmlLexer, MakoLexer,
+ **options)
+
+class MakoXmlLexer(DelegatingLexer):
+ name = 'XML+Mako'
+ aliases = ['xml+mako']
+
+ def __init__(self, **options):
+ super(MakoXmlLexer, self).__init__(XmlLexer, MakoLexer,
+ **options)
+
+class MakoJavascriptLexer(DelegatingLexer):
+ name = 'JavaScript+Mako'
+ aliases = ['js+mako', 'javascript+mako']
+
+ def __init__(self, **options):
+ super(MakoJavascriptLexer, self).__init__(JavascriptLexer,
+ MakoLexer, **options)
+
+class MakoCssLexer(DelegatingLexer):
+ name = 'CSS+Mako'
+ aliases = ['css+mako']
+
+ def __init__(self, **options):
+ super(MakoCssLexer, self).__init__(CssLexer, MakoLexer,
+ **options)
diff --git a/mako/ext/turbogears.py b/mako/ext/turbogears.py
new file mode 100644
index 00000000..f7822eea
--- /dev/null
+++ b/mako/ext/turbogears.py
@@ -0,0 +1,56 @@
+# ext/turbogears.py
+# Copyright (C) 2006-2011 the Mako authors and contributors
+#
+# This module is part of Mako and is released under
+# the MIT License: http://www.opensource.org/licenses/mit-license.php
+
+import re, inspect
+from mako.lookup import TemplateLookup
+from mako.template import Template
+
+class TGPlugin(object):
+ """TurboGears compatible Template Plugin."""
+
+ def __init__(self, extra_vars_func=None, options=None, extension='mak'):
+ self.extra_vars_func = extra_vars_func
+ self.extension = extension
+ if not options:
+ options = {}
+
+ # Pull the options out and initialize the lookup
+ lookup_options = {}
+ for k, v in options.iteritems():
+ if k.startswith('mako.'):
+ lookup_options[k[5:]] = v
+ elif k in ['directories', 'filesystem_checks', 'module_directory']:
+ lookup_options[k] = v
+ self.lookup = TemplateLookup(**lookup_options)
+
+ self.tmpl_options = {}
+ # transfer lookup args to template args, based on those available
+ # in getargspec
+ for kw in inspect.getargspec(Template.__init__)[0]:
+ if kw in lookup_options:
+ self.tmpl_options[kw] = lookup_options[kw]
+
+ def load_template(self, templatename, template_string=None):
+ """Loads a template from a file or a string"""
+ if template_string is not None:
+ return Template(template_string, **self.tmpl_options)
+ # Translate TG dot notation to normal / template path
+ if '/' not in templatename:
+ templatename = '/' + templatename.replace('.', '/') + '.' + self.extension
+
+ # Lookup template
+ return self.lookup.get_template(templatename)
+
+ def render(self, info, format="html", fragment=False, template=None):
+ if isinstance(template, basestring):
+ template = self.load_template(template)
+
+ # Load extra vars func if provided
+ if self.extra_vars_func:
+ info.update(self.extra_vars_func())
+
+ return template.render(**info)
+
diff --git a/mako/filters.py b/mako/filters.py
new file mode 100644
index 00000000..30c792f2
--- /dev/null
+++ b/mako/filters.py
@@ -0,0 +1,188 @@
+# mako/filters.py
+# Copyright (C) 2006-2011 the Mako authors and contributors
+#
+# This module is part of Mako and is released under
+# the MIT License: http://www.opensource.org/licenses/mit-license.php
+
+
+import re, urllib, htmlentitydefs, codecs
+from StringIO import StringIO
+from mako import util
+
+xml_escapes = {
+ '&' : '&',
+ '>' : '>',
+ '<' : '<',
+ '"' : '"', # also " in html-only
+ "'" : ''' # also ' in html-only
+}
+
+# XXX: " is valid in HTML and XML
+# ' is not valid HTML, but is valid XML
+
+def legacy_html_escape(string):
+ """legacy HTML escape for non-unicode mode."""
+
+ return re.sub(r'([&<"\'>])', lambda m: xml_escapes[m.group()], string)
+
+try:
+ import markupsafe
+ html_escape = markupsafe.escape
+except ImportError:
+ html_escape = legacy_html_escape
+
+
+def xml_escape(string):
+ return re.sub(r'([&<"\'>])', lambda m: xml_escapes[m.group()], string)
+
+def url_escape(string):
+ # convert into a list of octets
+ string = string.encode("utf8")
+ return urllib.quote_plus(string)
+
+def url_unescape(string):
+ text = urllib.unquote_plus(string)
+ if not is_ascii_str(text):
+ text = text.decode("utf8")
+ return text
+
+def trim(string):
+ return string.strip()
+
+
+class Decode(object):
+ def __getattr__(self, key):
+ def decode(x):
+ if isinstance(x, unicode):
+ return x
+ elif not isinstance(x, str):
+ return unicode(str(x), encoding=key)
+ else:
+ return unicode(x, encoding=key)
+ return decode
+decode = Decode()
+
+
+_ASCII_re = re.compile(r'\A[\x00-\x7f]*\Z')
+
+def is_ascii_str(text):
+ return isinstance(text, str) and _ASCII_re.match(text)
+
+################################################################
+
+class XMLEntityEscaper(object):
+ def __init__(self, codepoint2name, name2codepoint):
+ self.codepoint2entity = dict([(c, u'&%s;' % n)
+ for c,n in codepoint2name.iteritems()])
+ self.name2codepoint = name2codepoint
+
+ def escape_entities(self, text):
+ """Replace characters with their character entity references.
+
+ Only characters corresponding to a named entity are replaced.
+ """
+ return unicode(text).translate(self.codepoint2entity)
+
+ def __escape(self, m):
+ codepoint = ord(m.group())
+ try:
+ return self.codepoint2entity[codepoint]
+ except (KeyError, IndexError):
+ return '&#x%X;' % codepoint
+
+
+ __escapable = re.compile(r'["&<>]|[^\x00-\x7f]')
+
+ def escape(self, text):
+ """Replace characters with their character references.
+
+ Replace characters by their named entity references.
+ Non-ASCII characters, if they do not have a named entity reference,
+ are replaced by numerical character references.
+
+ The return value is guaranteed to be ASCII.
+ """
+ return self.__escapable.sub(self.__escape, unicode(text)
+ ).encode('ascii')
+
+ # XXX: This regexp will not match all valid XML entity names__.
+ # (It punts on details involving involving CombiningChars and Extenders.)
+ #
+ # .. __: http://www.w3.org/TR/2000/REC-xml-20001006#NT-EntityRef
+ __characterrefs = re.compile(r'''& (?:
+ \#(\d+)
+ | \#x([\da-f]+)
+ | ( (?!\d) [:\w] [-.:\w]+ )
+ ) ;''',
+ re.X | re.UNICODE)
+
+ def __unescape(self, m):
+ dval, hval, name = m.groups()
+ if dval:
+ codepoint = int(dval)
+ elif hval:
+ codepoint = int(hval, 16)
+ else:
+ codepoint = self.name2codepoint.get(name, 0xfffd)
+ # U+FFFD = "REPLACEMENT CHARACTER"
+ if codepoint < 128:
+ return chr(codepoint)
+ return unichr(codepoint)
+
+ def unescape(self, text):
+ """Unescape character references.
+
+ All character references (both entity references and numerical
+ character references) are unescaped.
+ """
+ return self.__characterrefs.sub(self.__unescape, text)
+
+
+_html_entities_escaper = XMLEntityEscaper(htmlentitydefs.codepoint2name,
+ htmlentitydefs.name2codepoint)
+
+html_entities_escape = _html_entities_escaper.escape_entities
+html_entities_unescape = _html_entities_escaper.unescape
+
+
+def htmlentityreplace_errors(ex):
+ """An encoding error handler.
+
+ This python `codecs`_ error handler replaces unencodable
+ characters with HTML entities, or, if no HTML entity exists for
+ the character, XML character references.
+
+ >>> u'The cost was \u20ac12.'.encode('latin1', 'htmlentityreplace')
+ 'The cost was €12.'
+ """
+ if isinstance(ex, UnicodeEncodeError):
+ # Handle encoding errors
+ bad_text = ex.object[ex.start:ex.end]
+ text = _html_entities_escaper.escape(bad_text)
+ return (unicode(text), ex.end)
+ raise ex
+
+codecs.register_error('htmlentityreplace', htmlentityreplace_errors)
+
+
+# TODO: options to make this dynamic per-compilation will be added in a later release
+DEFAULT_ESCAPES = {
+ 'x':'filters.xml_escape',
+ 'h':'filters.html_escape',
+ 'u':'filters.url_escape',
+ 'trim':'filters.trim',
+ 'entity':'filters.html_entities_escape',
+ 'unicode':'unicode',
+ 'decode':'decode',
+ 'str':'str',
+ 'n':'n'
+}
+
+if util.py3k:
+ DEFAULT_ESCAPES.update({
+ 'unicode':'str'
+ })
+
+NON_UNICODE_ESCAPES = DEFAULT_ESCAPES.copy()
+NON_UNICODE_ESCAPES['h'] = 'filters.legacy_html_escape'
+
diff --git a/mako/lexer.py b/mako/lexer.py
new file mode 100644
index 00000000..cf06bb52
--- /dev/null
+++ b/mako/lexer.py
@@ -0,0 +1,415 @@
+# mako/lexer.py
+# Copyright (C) 2006-2011 the Mako authors and contributors
+#
+# This module is part of Mako and is released under
+# the MIT License: http://www.opensource.org/licenses/mit-license.php
+
+"""provides the Lexer class for parsing template strings into parse trees."""
+
+import re, codecs
+from mako import parsetree, exceptions, util
+from mako.pygen import adjust_whitespace
+
+_regexp_cache = {}
+
+class Lexer(object):
+ def __init__(self, text, filename=None,
+ disable_unicode=False,
+ input_encoding=None, preprocessor=None):
+ self.text = text
+ self.filename = filename
+ self.template = parsetree.TemplateNode(self.filename)
+ self.matched_lineno = 1
+ self.matched_charpos = 0
+ self.lineno = 1
+ self.match_position = 0
+ self.tag = []
+ self.control_line = []
+ self.disable_unicode = disable_unicode
+ self.encoding = input_encoding
+
+ if util.py3k and disable_unicode:
+ raise exceptions.UnsupportedError(
+ "Mako for Python 3 does not "
+ "support disabling Unicode")
+
+ if preprocessor is None:
+ self.preprocessor = []
+ elif not hasattr(preprocessor, '__iter__'):
+ self.preprocessor = [preprocessor]
+ else:
+ self.preprocessor = preprocessor
+
+ @property
+ def exception_kwargs(self):
+ return {'source':self.text,
+ 'lineno':self.matched_lineno,
+ 'pos':self.matched_charpos,
+ 'filename':self.filename}
+
+ def match(self, regexp, flags=None):
+ """compile the given regexp, cache the reg, and call match_reg()."""
+
+ try:
+ reg = _regexp_cache[(regexp, flags)]
+ except KeyError:
+ if flags:
+ reg = re.compile(regexp, flags)
+ else:
+ reg = re.compile(regexp)
+ _regexp_cache[(regexp, flags)] = reg
+
+ return self.match_reg(reg)
+
+ def match_reg(self, reg):
+ """match the given regular expression object to the current text position.
+
+ if a match occurs, update the current text and line position.
+
+ """
+
+ mp = self.match_position
+
+ match = reg.match(self.text, self.match_position)
+ if match:
+ (start, end) = match.span()
+ if end == start:
+ self.match_position = end + 1
+ else:
+ self.match_position = end
+ self.matched_lineno = self.lineno
+ lines = re.findall(r"\n", self.text[mp:self.match_position])
+ cp = mp - 1
+ while (cp >= 0 and cp self.textlength:
+ break
+
+ if self.match_end():
+ break
+ if self.match_expression():
+ continue
+ if self.match_control_line():
+ continue
+ if self.match_comment():
+ continue
+ if self.match_tag_start():
+ continue
+ if self.match_tag_end():
+ continue
+ if self.match_python_block():
+ continue
+ if self.match_text():
+ continue
+
+ if self.match_position > self.textlength:
+ break
+ raise exceptions.CompileException("assertion failed")
+
+ if len(self.tag):
+ raise exceptions.SyntaxException("Unclosed tag: <%%%s>" %
+ self.tag[-1].keyword,
+ **self.exception_kwargs)
+ if len(self.control_line):
+ raise exceptions.SyntaxException("Unterminated control keyword: '%s'" %
+ self.control_line[-1].keyword,
+ self.text,
+ self.control_line[-1].lineno,
+ self.control_line[-1].pos, self.filename)
+ return self.template
+
+ def match_tag_start(self):
+ match = self.match(r'''
+ \<% # opening tag
+
+ ([\w\.\:]+) # keyword
+
+ ((?:\s+\w+|\s*=\s*|".*?"|'.*?')*) # attrname, = sign, string expression
+
+ \s* # more whitespace
+
+ (/)?> # closing
+
+ ''',
+
+ re.I | re.S | re.X)
+
+ if match:
+ keyword, attr, isend = match.group(1), match.group(2), match.group(3)
+ self.keyword = keyword
+ attributes = {}
+ if attr:
+ for att in re.findall(r"\s*(\w+)\s*=\s*(?:'([^']*)'|\"([^\"]*)\")", attr):
+ key, val1, val2 = att
+ text = val1 or val2
+ text = text.replace('\r\n', '\n')
+ attributes[key] = text
+ self.append_node(parsetree.Tag, keyword, attributes)
+ if isend:
+ self.tag.pop()
+ else:
+ if keyword == 'text':
+ match = self.match(r'(.*?)(?=\)', re.S)
+ if not match:
+ raise exceptions.SyntaxException(
+ "Unclosed tag: <%%%s>" %
+ self.tag[-1].keyword,
+ **self.exception_kwargs)
+ self.append_node(parsetree.Text, match.group(1))
+ return self.match_tag_end()
+ return True
+ else:
+ return False
+
+ def match_tag_end(self):
+ match = self.match(r'\')
+ if match:
+ if not len(self.tag):
+ raise exceptions.SyntaxException(
+ "Closing tag without opening tag: " %
+ match.group(1),
+ **self.exception_kwargs)
+ elif self.tag[-1].keyword != match.group(1):
+ raise exceptions.SyntaxException(
+ "Closing tag does not match tag: <%%%s>" %
+ (match.group(1), self.tag[-1].keyword),
+ **self.exception_kwargs)
+ self.tag.pop()
+ return True
+ else:
+ return False
+
+ def match_end(self):
+ match = self.match(r'\Z', re.S)
+ if match:
+ string = match.group()
+ if string:
+ return string
+ else:
+ return True
+ else:
+ return False
+
+ def match_text(self):
+ match = self.match(r"""
+ (.*?) # anything, followed by:
+ (
+ (?<=\n)(?=[ \t]*(?=%|\#\#)) # an eval or line-based
+ # comment preceded by a
+ # consumed newline and whitespace
+ |
+ (?=\${) # an expression
+ |
+ (?=\#\*) # multiline comment
+ |
+ (?=')
+ # the trailing newline helps
+ # compiler.parse() not complain about indentation
+ text = adjust_whitespace(text) + "\n"
+ self.append_node(
+ parsetree.Code,
+ text,
+ match.group(1)=='!', lineno=line, pos=pos)
+ return True
+ else:
+ return False
+
+ def match_expression(self):
+ match = self.match(r"\${")
+ if match:
+ line, pos = self.matched_lineno, self.matched_charpos
+ text, end = self.parse_until_text(r'\|', r'}')
+ if end == '|':
+ escapes, end = self.parse_until_text(r'}')
+ else:
+ escapes = ""
+ text = text.replace('\r\n', '\n')
+ self.append_node(
+ parsetree.Expression,
+ text, escapes.strip(),
+ lineno=line, pos=pos)
+ return True
+ else:
+ return False
+
+ def match_control_line(self):
+ match = self.match(r"(?<=^)[\t ]*(%(?!%)|##)[\t ]*((?:(?:\\r?\n)|[^\r\n])*)(?:\r?\n|\Z)", re.M)
+ if match:
+ operator = match.group(1)
+ text = match.group(2)
+ if operator == '%':
+ m2 = re.match(r'(end)?(\w+)\s*(.*)', text)
+ if not m2:
+ raise exceptions.SyntaxException(
+ "Invalid control line: '%s'" %
+ text,
+ **self.exception_kwargs)
+ isend, keyword = m2.group(1, 2)
+ isend = (isend is not None)
+
+ if isend:
+ if not len(self.control_line):
+ raise exceptions.SyntaxException(
+ "No starting keyword '%s' for '%s'" %
+ (keyword, text),
+ **self.exception_kwargs)
+ elif self.control_line[-1].keyword != keyword:
+ raise exceptions.SyntaxException(
+ "Keyword '%s' doesn't match keyword '%s'" %
+ (text, self.control_line[-1].keyword),
+ **self.exception_kwargs)
+ self.append_node(parsetree.ControlLine, keyword, isend, text)
+ else:
+ self.append_node(parsetree.Comment, text)
+ return True
+ else:
+ return False
+
+ def match_comment(self):
+ """matches the multiline version of a comment"""
+ match = self.match(r"<%doc>(.*?)", re.S)
+ if match:
+ self.append_node(parsetree.Comment, match.group(1))
+ return True
+ else:
+ return False
+
diff --git a/mako/lookup.py b/mako/lookup.py
new file mode 100644
index 00000000..b397d21f
--- /dev/null
+++ b/mako/lookup.py
@@ -0,0 +1,331 @@
+# mako/lookup.py
+# Copyright (C) 2006-2011 the Mako authors and contributors
+#
+# This module is part of Mako and is released under
+# the MIT License: http://www.opensource.org/licenses/mit-license.php
+
+import os, stat, posixpath, re
+from mako import exceptions, util
+from mako.template import Template
+
+try:
+ import threading
+except:
+ import dummy_threading as threading
+
+class TemplateCollection(object):
+ """Represent a collection of :class:`.Template` objects,
+ identifiable via uri.
+
+ A :class:`.TemplateCollection` is linked to the usage of
+ all template tags that address other templates, such
+ as ``<%include>``, ``<%namespace>``, and ``<%inherit>``.
+ The ``file`` attribute of each of those tags refers
+ to a string URI that is passed to that :class:`.Template`
+ object's :class:`.TemplateCollection` for resolution.
+
+ :class:`.TemplateCollection` is an abstract class,
+ with the usual default implementation being :class:`.TemplateLookup`.
+
+ """
+
+ def has_template(self, uri):
+ """Return ``True`` if this :class:`.TemplateLookup` is
+ capable of returning a :class:`.Template` object for the
+ given URL.
+
+ :param uri: String uri of the template to be resolved.
+
+ """
+ try:
+ self.get_template(uri)
+ return True
+ except exceptions.TemplateLookupException:
+ return False
+
+ def get_template(self, uri, relativeto=None):
+ """Return a :class:`.Template` object corresponding to the given
+ URL.
+
+ The default implementation raises
+ :class:`.NotImplementedError`. Implementations should
+ raise :class:`.TemplateLookupException` if the given uri
+ cannot be resolved.
+
+ :param uri: String uri of the template to be resolved.
+ :param relativeto: if present, the given URI is assumed to
+ be relative to this uri.
+
+ """
+ raise NotImplementedError()
+
+ def filename_to_uri(self, uri, filename):
+ """Convert the given filename to a uri relative to
+ this TemplateCollection."""
+
+ return uri
+
+ def adjust_uri(self, uri, filename):
+ """Adjust the given uri based on the calling filename.
+
+ When this method is called from the runtime, the
+ 'filename' parameter is taken directly to the 'filename'
+ attribute of the calling template. Therefore a custom
+ TemplateCollection subclass can place any string
+ identifier desired in the "filename" parameter of the
+ Template objects it constructs and have them come back
+ here.
+
+ """
+ return uri
+
+class TemplateLookup(TemplateCollection):
+ """Represent a collection of templates that locates template source files
+ from the local filesystem.
+
+ The primary argument is the ``directories`` argument, the list of
+ directories to search::
+
+ lookup = TemplateLookup(["/path/to/templates"])
+ some_template = lookup.get_template("/index.html")
+
+ The :class:`.TemplateLookup` can also be given :class:`.Template` objects
+ programatically using :meth:`.put_string` or :meth:`.put_template`::
+
+ lookup = TemplateLookup()
+ lookup.put_string("base.html", '''
+ ${self.next()}
+ ''')
+ lookup.put_string("hello.html", '''
+ <%include file='base.html'/>
+
+ Hello, world !
+ ''')
+
+
+ :param directories: A list of directory names which will be
+ searched for a particular template URI. The URI is appended
+ to each directory and the filesystem checked.
+
+ :param collection_size: Approximate size of the collection used
+ to store templates. If left at its default of -1, the size
+ is unbounded, and a plain Python dictionary is used to
+ relate URI strings to :class:`.Template` instances.
+ Otherwise, a least-recently-used cache object is used which
+ will maintain the size of the collection approximately to
+ the number given.
+
+ :param filesystem_checks: When at its default value of ``True``,
+ each call to :meth:`TemplateLookup.get_template()` will
+ compare the filesystem last modified time to the time in
+ which an existing :class:`.Template` object was created.
+ This allows the :class:`.TemplateLookup` to regenerate a
+ new :class:`.Template` whenever the original source has
+ been updated. Set this to ``False`` for a very minor
+ performance increase.
+
+ :param modulename_callable: A callable which, when present,
+ is passed the path of the source file as well as the
+ requested URI, and then returns the full path of the
+ generated Python module file. This is used to inject
+ alternate schemes for Pyhton module location. If left at
+ its default of ``None``, the built in system of generation
+ based on ``module_directory`` plus ``uri`` is used.
+
+ All other keyword parameters available for
+ :class:`.Template` are mirrored here. When new
+ :class:`.Template` objects are created, the keywords
+ established with this :class:`.TemplateLookup` are passed on
+ to each new :class:`.Template`.
+
+ """
+
+ def __init__(self,
+ directories=None,
+ module_directory=None,
+ filesystem_checks=True,
+ collection_size=-1,
+ format_exceptions=False,
+ error_handler=None,
+ disable_unicode=False,
+ bytestring_passthrough=False,
+ output_encoding=None,
+ encoding_errors='strict',
+ cache_type=None,
+ cache_dir=None, cache_url=None,
+ cache_enabled=True,
+ modulename_callable=None,
+ default_filters=None,
+ buffer_filters=(),
+ strict_undefined=False,
+ imports=None,
+ input_encoding=None,
+ preprocessor=None):
+
+ self.directories = [posixpath.normpath(d) for d in
+ util.to_list(directories, ())
+ ]
+ self.module_directory = module_directory
+ self.modulename_callable = modulename_callable
+ self.filesystem_checks = filesystem_checks
+ self.collection_size = collection_size
+
+ self.template_args = {
+ 'format_exceptions':format_exceptions,
+ 'error_handler':error_handler,
+ 'disable_unicode':disable_unicode,
+ 'bytestring_passthrough':bytestring_passthrough,
+ 'output_encoding':output_encoding,
+ 'encoding_errors':encoding_errors,
+ 'input_encoding':input_encoding,
+ 'module_directory':module_directory,
+ 'cache_type':cache_type,
+ 'cache_dir':cache_dir or module_directory,
+ 'cache_url':cache_url,
+ 'cache_enabled':cache_enabled,
+ 'default_filters':default_filters,
+ 'buffer_filters':buffer_filters,
+ 'strict_undefined':strict_undefined,
+ 'imports':imports,
+ 'preprocessor':preprocessor}
+
+ if collection_size == -1:
+ self._collection = {}
+ self._uri_cache = {}
+ else:
+ self._collection = util.LRUCache(collection_size)
+ self._uri_cache = util.LRUCache(collection_size)
+ self._mutex = threading.Lock()
+
+ def get_template(self, uri):
+ """Return a :class:`.Template` object corresponding to the given
+ URL.
+
+ Note the "relativeto" argument is not supported here at the moment.
+
+ """
+
+ try:
+ if self.filesystem_checks:
+ return self._check(uri, self._collection[uri])
+ else:
+ return self._collection[uri]
+ except KeyError:
+ u = re.sub(r'^\/+', '', uri)
+ for dir in self.directories:
+ srcfile = posixpath.normpath(posixpath.join(dir, u))
+ if os.path.isfile(srcfile):
+ return self._load(srcfile, uri)
+ else:
+ raise exceptions.TopLevelLookupException(
+ "Cant locate template for uri %r" % uri)
+
+ def adjust_uri(self, uri, relativeto):
+ """adjust the given uri based on the given relative uri."""
+
+ key = (uri, relativeto)
+ if key in self._uri_cache:
+ return self._uri_cache[key]
+
+ if uri[0] != '/':
+ if relativeto is not None:
+ v = self._uri_cache[key] = posixpath.join(posixpath.dirname(relativeto), uri)
+ else:
+ v = self._uri_cache[key] = '/' + uri
+ else:
+ v = self._uri_cache[key] = uri
+ return v
+
+
+ def filename_to_uri(self, filename):
+ """Convert the given filename to a uri relative to
+ this TemplateCollection."""
+
+ try:
+ return self._uri_cache[filename]
+ except KeyError:
+ value = self._relativeize(filename)
+ self._uri_cache[filename] = value
+ return value
+
+ def _relativeize(self, filename):
+ """Return the portion of a filename that is 'relative'
+ to the directories in this lookup.
+
+ """
+
+ filename = posixpath.normpath(filename)
+ for dir in self.directories:
+ if filename[0:len(dir)] == dir:
+ return filename[len(dir):]
+ else:
+ return None
+
+ def _load(self, filename, uri):
+ self._mutex.acquire()
+ try:
+ try:
+ # try returning from collection one
+ # more time in case concurrent thread already loaded
+ return self._collection[uri]
+ except KeyError:
+ pass
+ try:
+ if self.modulename_callable is not None:
+ module_filename = self.modulename_callable(filename, uri)
+ else:
+ module_filename = None
+ self._collection[uri] = template = Template(
+ uri=uri,
+ filename=posixpath.normpath(filename),
+ lookup=self,
+ module_filename=module_filename,
+ **self.template_args)
+ return template
+ except:
+ # if compilation fails etc, ensure
+ # template is removed from collection,
+ # re-raise
+ self._collection.pop(uri, None)
+ raise
+ finally:
+ self._mutex.release()
+
+ def _check(self, uri, template):
+ if template.filename is None:
+ return template
+
+ try:
+ template_stat = os.stat(template.filename)
+ if template.module._modified_time < \
+ template_stat[stat.ST_MTIME]:
+ self._collection.pop(uri, None)
+ return self._load(template.filename, uri)
+ else:
+ return template
+ except OSError:
+ self._collection.pop(uri, None)
+ raise exceptions.TemplateLookupException(
+ "Cant locate template for uri %r" % uri)
+
+
+ def put_string(self, uri, text):
+ """Place a new :class:`.Template` object into this
+ :class:`.TemplateLookup`, based on the given string of
+ text.
+
+ """
+ self._collection[uri] = Template(
+ text,
+ lookup=self,
+ uri=uri,
+ **self.template_args)
+
+ def put_template(self, uri, template):
+ """Place a new :class:`.Template` object into this
+ :class:`.TemplateLookup`, based on the given
+ :class:`.Template` object.
+
+ """
+ self._collection[uri] = template
+
diff --git a/mako/parsetree.py b/mako/parsetree.py
new file mode 100644
index 00000000..31b9b4f0
--- /dev/null
+++ b/mako/parsetree.py
@@ -0,0 +1,565 @@
+# mako/parsetree.py
+# Copyright (C) 2006-2011 the Mako authors and contributors
+#
+# This module is part of Mako and is released under
+# the MIT License: http://www.opensource.org/licenses/mit-license.php
+
+"""defines the parse tree components for Mako templates."""
+
+from mako import exceptions, ast, util, filters
+import re
+
+class Node(object):
+ """base class for a Node in the parse tree."""
+ def __init__(self, source, lineno, pos, filename):
+ self.source = source
+ self.lineno = lineno
+ self.pos = pos
+ self.filename = filename
+
+ @property
+ def exception_kwargs(self):
+ return {'source':self.source, 'lineno':self.lineno,
+ 'pos':self.pos, 'filename':self.filename}
+
+ def get_children(self):
+ return []
+
+ def accept_visitor(self, visitor):
+ def traverse(node):
+ for n in node.get_children():
+ n.accept_visitor(visitor)
+ method = getattr(visitor, "visit" + self.__class__.__name__, traverse)
+ method(self)
+
+class TemplateNode(Node):
+ """a 'container' node that stores the overall collection of nodes."""
+
+ def __init__(self, filename):
+ super(TemplateNode, self).__init__('', 0, 0, filename)
+ self.nodes = []
+ self.page_attributes = {}
+
+ def get_children(self):
+ return self.nodes
+
+ def __repr__(self):
+ return "TemplateNode(%s, %r)" % (
+ util.sorted_dict_repr(self.page_attributes),
+ self.nodes)
+
+class ControlLine(Node):
+ """defines a control line, a line-oriented python line or end tag.
+
+ e.g.::
+
+ % if foo:
+ (markup)
+ % endif
+
+ """
+
+ def __init__(self, keyword, isend, text, **kwargs):
+ super(ControlLine, self).__init__(**kwargs)
+ self.text = text
+ self.keyword = keyword
+ self.isend = isend
+ self.is_primary = keyword in ['for','if', 'while', 'try']
+ if self.isend:
+ self._declared_identifiers = []
+ self._undeclared_identifiers = []
+ else:
+ code = ast.PythonFragment(text, **self.exception_kwargs)
+ self._declared_identifiers = code.declared_identifiers
+ self._undeclared_identifiers = code.undeclared_identifiers
+
+ def declared_identifiers(self):
+ return self._declared_identifiers
+
+ def undeclared_identifiers(self):
+ return self._undeclared_identifiers
+
+ def is_ternary(self, keyword):
+ """return true if the given keyword is a ternary keyword
+ for this ControlLine"""
+
+ return keyword in {
+ 'if':set(['else', 'elif']),
+ 'try':set(['except', 'finally']),
+ 'for':set(['else'])
+ }.get(self.keyword, [])
+
+ def __repr__(self):
+ return "ControlLine(%r, %r, %r, %r)" % (
+ self.keyword,
+ self.text,
+ self.isend,
+ (self.lineno, self.pos)
+ )
+
+class Text(Node):
+ """defines plain text in the template."""
+
+ def __init__(self, content, **kwargs):
+ super(Text, self).__init__(**kwargs)
+ self.content = content
+
+ def __repr__(self):
+ return "Text(%r, %r)" % (self.content, (self.lineno, self.pos))
+
+class Code(Node):
+ """defines a Python code block, either inline or module level.
+
+ e.g.::
+
+ inline:
+ <%
+ x = 12
+ %>
+
+ module level:
+ <%!
+ import logger
+ %>
+
+ """
+
+ def __init__(self, text, ismodule, **kwargs):
+ super(Code, self).__init__(**kwargs)
+ self.text = text
+ self.ismodule = ismodule
+ self.code = ast.PythonCode(text, **self.exception_kwargs)
+
+ def declared_identifiers(self):
+ return self.code.declared_identifiers
+
+ def undeclared_identifiers(self):
+ return self.code.undeclared_identifiers
+
+ def __repr__(self):
+ return "Code(%r, %r, %r)" % (
+ self.text,
+ self.ismodule,
+ (self.lineno, self.pos)
+ )
+
+class Comment(Node):
+ """defines a comment line.
+
+ # this is a comment
+
+ """
+
+ def __init__(self, text, **kwargs):
+ super(Comment, self).__init__(**kwargs)
+ self.text = text
+
+ def __repr__(self):
+ return "Comment(%r, %r)" % (self.text, (self.lineno, self.pos))
+
+class Expression(Node):
+ """defines an inline expression.
+
+ ${x+y}
+
+ """
+
+ def __init__(self, text, escapes, **kwargs):
+ super(Expression, self).__init__(**kwargs)
+ self.text = text
+ self.escapes = escapes
+ self.escapes_code = ast.ArgumentList(escapes, **self.exception_kwargs)
+ self.code = ast.PythonCode(text, **self.exception_kwargs)
+
+ def declared_identifiers(self):
+ return []
+
+ def undeclared_identifiers(self):
+ # TODO: make the "filter" shortcut list configurable at parse/gen time
+ return self.code.undeclared_identifiers.union(
+ self.escapes_code.undeclared_identifiers.difference(
+ set(filters.DEFAULT_ESCAPES.keys())
+ )
+ ).difference(self.code.declared_identifiers)
+
+ def __repr__(self):
+ return "Expression(%r, %r, %r)" % (
+ self.text,
+ self.escapes_code.args,
+ (self.lineno, self.pos)
+ )
+
+class _TagMeta(type):
+ """metaclass to allow Tag to produce a subclass according to
+ its keyword"""
+
+ _classmap = {}
+
+ def __init__(cls, clsname, bases, dict):
+ if cls.__keyword__ is not None:
+ cls._classmap[cls.__keyword__] = cls
+ super(_TagMeta, cls).__init__(clsname, bases, dict)
+
+ def __call__(cls, keyword, attributes, **kwargs):
+ if ":" in keyword:
+ ns, defname = keyword.split(':')
+ return type.__call__(CallNamespaceTag, ns, defname,
+ attributes, **kwargs)
+
+ try:
+ cls = _TagMeta._classmap[keyword]
+ except KeyError:
+ raise exceptions.CompileException(
+ "No such tag: '%s'" % keyword,
+ source=kwargs['source'],
+ lineno=kwargs['lineno'],
+ pos=kwargs['pos'],
+ filename=kwargs['filename']
+ )
+ return type.__call__(cls, keyword, attributes, **kwargs)
+
+class Tag(Node):
+ """abstract base class for tags.
+
+ <%sometag/>
+
+ <%someothertag>
+ stuff
+
+
+ """
+
+ __metaclass__ = _TagMeta
+ __keyword__ = None
+
+ def __init__(self, keyword, attributes, expressions,
+ nonexpressions, required, **kwargs):
+ """construct a new Tag instance.
+
+ this constructor not called directly, and is only called
+ by subclasses.
+
+ :param keyword: the tag keyword
+
+ :param attributes: raw dictionary of attribute key/value pairs
+
+ :param expressions: a set of identifiers that are legal attributes,
+ which can also contain embedded expressions
+
+ :param nonexpressions: a set of identifiers that are legal
+ attributes, which cannot contain embedded expressions
+
+ :param \**kwargs:
+ other arguments passed to the Node superclass (lineno, pos)
+
+ """
+ super(Tag, self).__init__(**kwargs)
+ self.keyword = keyword
+ self.attributes = attributes
+ self._parse_attributes(expressions, nonexpressions)
+ missing = [r for r in required if r not in self.parsed_attributes]
+ if len(missing):
+ raise exceptions.CompileException(
+ "Missing attribute(s): %s" %
+ ",".join([repr(m) for m in missing]),
+ **self.exception_kwargs)
+ self.parent = None
+ self.nodes = []
+
+ def is_root(self):
+ return self.parent is None
+
+ def get_children(self):
+ return self.nodes
+
+ def _parse_attributes(self, expressions, nonexpressions):
+ undeclared_identifiers = set()
+ self.parsed_attributes = {}
+ for key in self.attributes:
+ if key in expressions:
+ expr = []
+ for x in re.compile(r'(\${.+?})',
+ re.S).split(self.attributes[key]):
+ m = re.compile(r'^\${(.+?)}$', re.S).match(x)
+ if m:
+ code = ast.PythonCode(m.group(1).rstrip(),
+ **self.exception_kwargs)
+ # we aren't discarding "declared_identifiers" here,
+ # which we do so that list comprehension-declared
+ # variables aren't counted. As yet can't find a
+ # condition that requires it here.
+ undeclared_identifiers = \
+ undeclared_identifiers.union(
+ code.undeclared_identifiers)
+ expr.append('(%s)' % m.group(1))
+ else:
+ if x:
+ expr.append(repr(x))
+ self.parsed_attributes[key] = " + ".join(expr) or repr('')
+ elif key in nonexpressions:
+ if re.search(r'\${.+?}', self.attributes[key]):
+ raise exceptions.CompileException(
+ "Attibute '%s' in tag '%s' does not allow embedded "
+ "expressions" % (key, self.keyword),
+ **self.exception_kwargs)
+ self.parsed_attributes[key] = repr(self.attributes[key])
+ else:
+ raise exceptions.CompileException(
+ "Invalid attribute for tag '%s': '%s'" %
+ (self.keyword, key),
+ **self.exception_kwargs)
+ self.expression_undeclared_identifiers = undeclared_identifiers
+
+ def declared_identifiers(self):
+ return []
+
+ def undeclared_identifiers(self):
+ return self.expression_undeclared_identifiers
+
+ def __repr__(self):
+ return "%s(%r, %s, %r, %r)" % (self.__class__.__name__,
+ self.keyword,
+ util.sorted_dict_repr(self.attributes),
+ (self.lineno, self.pos),
+ self.nodes
+ )
+
+class IncludeTag(Tag):
+ __keyword__ = 'include'
+
+ def __init__(self, keyword, attributes, **kwargs):
+ super(IncludeTag, self).__init__(
+ keyword,
+ attributes,
+ ('file', 'import', 'args'),
+ (), ('file',), **kwargs)
+ self.page_args = ast.PythonCode(
+ "__DUMMY(%s)" % attributes.get('args', ''),
+ **self.exception_kwargs)
+
+ def declared_identifiers(self):
+ return []
+
+ def undeclared_identifiers(self):
+ identifiers = self.page_args.undeclared_identifiers.\
+ difference(set(["__DUMMY"])).\
+ difference(self.page_args.declared_identifiers)
+ return identifiers.union(super(IncludeTag, self).
+ undeclared_identifiers())
+
+class NamespaceTag(Tag):
+ __keyword__ = 'namespace'
+
+ def __init__(self, keyword, attributes, **kwargs):
+ super(NamespaceTag, self).__init__(
+ keyword, attributes,
+ ('file',),
+ ('name','inheritable',
+ 'import','module'),
+ (), **kwargs)
+
+ self.name = attributes.get('name', '__anon_%s' % hex(abs(id(self))))
+ if not 'name' in attributes and not 'import' in attributes:
+ raise exceptions.CompileException(
+ "'name' and/or 'import' attributes are required "
+ "for <%namespace>",
+ **self.exception_kwargs)
+ if 'file' in attributes and 'module' in attributes:
+ raise exceptions.CompileException(
+ "<%namespace> may only have one of 'file' or 'module'",
+ **self.exception_kwargs
+ )
+
+ def declared_identifiers(self):
+ return []
+
+class TextTag(Tag):
+ __keyword__ = 'text'
+
+ def __init__(self, keyword, attributes, **kwargs):
+ super(TextTag, self).__init__(
+ keyword,
+ attributes, (),
+ ('filter'), (), **kwargs)
+ self.filter_args = ast.ArgumentList(
+ attributes.get('filter', ''),
+ **self.exception_kwargs)
+
+class DefTag(Tag):
+ __keyword__ = 'def'
+
+ def __init__(self, keyword, attributes, **kwargs):
+ super(DefTag, self).__init__(
+ keyword,
+ attributes,
+ ('buffered', 'cached', 'cache_key', 'cache_timeout',
+ 'cache_type', 'cache_dir', 'cache_url'),
+ ('name','filter', 'decorator'),
+ ('name',),
+ **kwargs)
+ name = attributes['name']
+ if re.match(r'^[\w_]+$',name):
+ raise exceptions.CompileException(
+ "Missing parenthesis in %def",
+ **self.exception_kwargs)
+ self.function_decl = ast.FunctionDecl("def " + name + ":pass",
+ **self.exception_kwargs)
+ self.name = self.function_decl.funcname
+ self.decorator = attributes.get('decorator', '')
+ self.filter_args = ast.ArgumentList(
+ attributes.get('filter', ''),
+ **self.exception_kwargs)
+
+ is_anonymous = False
+ is_block = False
+
+ @property
+ def funcname(self):
+ return self.function_decl.funcname
+
+ def get_argument_expressions(self, **kw):
+ return self.function_decl.get_argument_expressions(**kw)
+
+ def declared_identifiers(self):
+ return self.function_decl.argnames
+
+ def undeclared_identifiers(self):
+ res = []
+ for c in self.function_decl.defaults:
+ res += list(ast.PythonCode(c, **self.exception_kwargs).
+ undeclared_identifiers)
+ return res + list(self.filter_args.\
+ undeclared_identifiers.\
+ difference(filters.DEFAULT_ESCAPES.keys())
+ )
+
+class BlockTag(Tag):
+ __keyword__ = 'block'
+
+ def __init__(self, keyword, attributes, **kwargs):
+ super(BlockTag, self).__init__(
+ keyword,
+ attributes,
+ ('buffered', 'cached', 'cache_key', 'cache_timeout',
+ 'cache_type', 'cache_dir', 'cache_url', 'args'),
+ ('name','filter', 'decorator'),
+ (),
+ **kwargs)
+ name = attributes.get('name')
+ if name and not re.match(r'^[\w_]+$',name):
+ raise exceptions.CompileException(
+ "%block may not specify an argument signature",
+ **self.exception_kwargs)
+ if not name and attributes.get('args', None):
+ raise exceptions.CompileException(
+ "Only named %blocks may specify args",
+ **self.exception_kwargs
+ )
+ self.body_decl = ast.FunctionArgs(attributes.get('args', ''),
+ **self.exception_kwargs)
+
+ self.name = name
+ self.decorator = attributes.get('decorator', '')
+ self.filter_args = ast.ArgumentList(
+ attributes.get('filter', ''),
+ **self.exception_kwargs)
+
+
+ is_block = True
+
+ @property
+ def is_anonymous(self):
+ return self.name is None
+
+ @property
+ def funcname(self):
+ return self.name or "__M_anon_%d" % (self.lineno, )
+
+ def get_argument_expressions(self, **kw):
+ return self.body_decl.get_argument_expressions(**kw)
+
+ def declared_identifiers(self):
+ return self.body_decl.argnames
+
+ def undeclared_identifiers(self):
+ return []
+
+class CallTag(Tag):
+ __keyword__ = 'call'
+
+ def __init__(self, keyword, attributes, **kwargs):
+ super(CallTag, self).__init__(keyword, attributes,
+ ('args'), ('expr',), ('expr',), **kwargs)
+ self.expression = attributes['expr']
+ self.code = ast.PythonCode(self.expression, **self.exception_kwargs)
+ self.body_decl = ast.FunctionArgs(attributes.get('args', ''),
+ **self.exception_kwargs)
+
+ def declared_identifiers(self):
+ return self.code.declared_identifiers.union(self.body_decl.argnames)
+
+ def undeclared_identifiers(self):
+ return self.code.undeclared_identifiers.\
+ difference(self.code.declared_identifiers)
+
+class CallNamespaceTag(Tag):
+
+ def __init__(self, namespace, defname, attributes, **kwargs):
+ super(CallNamespaceTag, self).__init__(
+ namespace + ":" + defname,
+ attributes,
+ tuple(attributes.keys()) + ('args', ),
+ (),
+ (),
+ **kwargs)
+
+ self.expression = "%s.%s(%s)" % (
+ namespace,
+ defname,
+ ",".join(["%s=%s" % (k, v) for k, v in
+ self.parsed_attributes.iteritems()
+ if k != 'args'])
+ )
+ self.code = ast.PythonCode(self.expression, **self.exception_kwargs)
+ self.body_decl = ast.FunctionArgs(
+ attributes.get('args', ''),
+ **self.exception_kwargs)
+
+ def declared_identifiers(self):
+ return self.code.declared_identifiers.union(self.body_decl.argnames)
+
+ def undeclared_identifiers(self):
+ return self.code.undeclared_identifiers.\
+ difference(self.code.declared_identifiers)
+
+class InheritTag(Tag):
+ __keyword__ = 'inherit'
+
+ def __init__(self, keyword, attributes, **kwargs):
+ super(InheritTag, self).__init__(
+ keyword, attributes,
+ ('file',), (), ('file',), **kwargs)
+
+class PageTag(Tag):
+ __keyword__ = 'page'
+
+ def __init__(self, keyword, attributes, **kwargs):
+ super(PageTag, self).__init__(
+ keyword,
+ attributes,
+ ('cached', 'cache_key', 'cache_timeout',
+ 'cache_type', 'cache_dir', 'cache_url',
+ 'args', 'expression_filter'),
+ (),
+ (),
+ **kwargs)
+ self.body_decl = ast.FunctionArgs(attributes.get('args', ''),
+ **self.exception_kwargs)
+ self.filter_args = ast.ArgumentList(
+ attributes.get('expression_filter', ''),
+ **self.exception_kwargs)
+
+ def declared_identifiers(self):
+ return self.body_decl.argnames
+
+
diff --git a/mako/pygen.py b/mako/pygen.py
new file mode 100644
index 00000000..07f26670
--- /dev/null
+++ b/mako/pygen.py
@@ -0,0 +1,285 @@
+# mako/pygen.py
+# Copyright (C) 2006-2011 the Mako authors and contributors
+#
+# This module is part of Mako and is released under
+# the MIT License: http://www.opensource.org/licenses/mit-license.php
+
+"""utilities for generating and formatting literal Python code."""
+
+import re, string
+from StringIO import StringIO
+from mako import exceptions
+
+class PythonPrinter(object):
+ def __init__(self, stream):
+ # indentation counter
+ self.indent = 0
+
+ # a stack storing information about why we incremented
+ # the indentation counter, to help us determine if we
+ # should decrement it
+ self.indent_detail = []
+
+ # the string of whitespace multiplied by the indent
+ # counter to produce a line
+ self.indentstring = " "
+
+ # the stream we are writing to
+ self.stream = stream
+
+ # a list of lines that represents a buffered "block" of code,
+ # which can be later printed relative to an indent level
+ self.line_buffer = []
+
+ self.in_indent_lines = False
+
+ self._reset_multi_line_flags()
+
+ def write(self, text):
+ self.stream.write(text)
+
+ def write_indented_block(self, block):
+ """print a line or lines of python which already contain indentation.
+
+ The indentation of the total block of lines will be adjusted to that of
+ the current indent level."""
+ self.in_indent_lines = False
+ for l in re.split(r'\r?\n', block):
+ self.line_buffer.append(l)
+
+ def writelines(self, *lines):
+ """print a series of lines of python."""
+ for line in lines:
+ self.writeline(line)
+
+ def writeline(self, line):
+ """print a line of python, indenting it according to the current
+ indent level.
+
+ this also adjusts the indentation counter according to the
+ content of the line.
+
+ """
+
+ if not self.in_indent_lines:
+ self._flush_adjusted_lines()
+ self.in_indent_lines = True
+
+ decreased_indent = False
+
+ if (line is None or
+ re.match(r"^\s*#",line) or
+ re.match(r"^\s*$", line)
+ ):
+ hastext = False
+ else:
+ hastext = True
+
+ is_comment = line and len(line) and line[0] == '#'
+
+ # see if this line should decrease the indentation level
+ if (not decreased_indent and
+ not is_comment and
+ (not hastext or self._is_unindentor(line))
+ ):
+
+ if self.indent > 0:
+ self.indent -=1
+ # if the indent_detail stack is empty, the user
+ # probably put extra closures - the resulting
+ # module wont compile.
+ if len(self.indent_detail) == 0:
+ raise exceptions.SyntaxException(
+ "Too many whitespace closures")
+ self.indent_detail.pop()
+
+ if line is None:
+ return
+
+ # write the line
+ self.stream.write(self._indent_line(line) + "\n")
+
+ # see if this line should increase the indentation level.
+ # note that a line can both decrase (before printing) and
+ # then increase (after printing) the indentation level.
+
+ if re.search(r":[ \t]*(?:#.*)?$", line):
+ # increment indentation count, and also
+ # keep track of what the keyword was that indented us,
+ # if it is a python compound statement keyword
+ # where we might have to look for an "unindent" keyword
+ match = re.match(r"^\s*(if|try|elif|while|for)", line)
+ if match:
+ # its a "compound" keyword, so we will check for "unindentors"
+ indentor = match.group(1)
+ self.indent +=1
+ self.indent_detail.append(indentor)
+ else:
+ indentor = None
+ # its not a "compound" keyword. but lets also
+ # test for valid Python keywords that might be indenting us,
+ # else assume its a non-indenting line
+ m2 = re.match(r"^\s*(def|class|else|elif|except|finally)", line)
+ if m2:
+ self.indent += 1
+ self.indent_detail.append(indentor)
+
+ def close(self):
+ """close this printer, flushing any remaining lines."""
+ self._flush_adjusted_lines()
+
+ def _is_unindentor(self, line):
+ """return true if the given line is an 'unindentor',
+ relative to the last 'indent' event received.
+
+ """
+
+ # no indentation detail has been pushed on; return False
+ if len(self.indent_detail) == 0:
+ return False
+
+ indentor = self.indent_detail[-1]
+
+ # the last indent keyword we grabbed is not a
+ # compound statement keyword; return False
+ if indentor is None:
+ return False
+
+ # if the current line doesnt have one of the "unindentor" keywords,
+ # return False
+ match = re.match(r"^\s*(else|elif|except|finally).*\:", line)
+ if not match:
+ return False
+
+ # whitespace matches up, we have a compound indentor,
+ # and this line has an unindentor, this
+ # is probably good enough
+ return True
+
+ # should we decide that its not good enough, heres
+ # more stuff to check.
+ #keyword = match.group(1)
+
+ # match the original indent keyword
+ #for crit in [
+ # (r'if|elif', r'else|elif'),
+ # (r'try', r'except|finally|else'),
+ # (r'while|for', r'else'),
+ #]:
+ # if re.match(crit[0], indentor) and re.match(crit[1], keyword):
+ # return True
+
+ #return False
+
+ def _indent_line(self, line, stripspace=''):
+ """indent the given line according to the current indent level.
+
+ stripspace is a string of space that will be truncated from the
+ start of the line before indenting."""
+
+ return re.sub(r"^%s" % stripspace, self.indentstring
+ * self.indent, line)
+
+ def _reset_multi_line_flags(self):
+ """reset the flags which would indicate we are in a backslashed
+ or triple-quoted section."""
+
+ self.backslashed, self.triplequoted = False, False
+
+ def _in_multi_line(self, line):
+ """return true if the given line is part of a multi-line block,
+ via backslash or triple-quote."""
+
+ # we are only looking for explicitly joined lines here, not
+ # implicit ones (i.e. brackets, braces etc.). this is just to
+ # guard against the possibility of modifying the space inside of
+ # a literal multiline string with unfortunately placed
+ # whitespace
+
+ current_state = (self.backslashed or self.triplequoted)
+
+ if re.search(r"\\$", line):
+ self.backslashed = True
+ else:
+ self.backslashed = False
+
+ triples = len(re.findall(r"\"\"\"|\'\'\'", line))
+ if triples == 1 or triples % 2 != 0:
+ self.triplequoted = not self.triplequoted
+
+ return current_state
+
+ def _flush_adjusted_lines(self):
+ stripspace = None
+ self._reset_multi_line_flags()
+
+ for entry in self.line_buffer:
+ if self._in_multi_line(entry):
+ self.stream.write(entry + "\n")
+ else:
+ entry = entry.expandtabs()
+ if stripspace is None and re.search(r"^[ \t]*[^# \t]", entry):
+ stripspace = re.match(r"^([ \t]*)", entry).group(1)
+ self.stream.write(self._indent_line(entry, stripspace) + "\n")
+
+ self.line_buffer = []
+ self._reset_multi_line_flags()
+
+
+def adjust_whitespace(text):
+ """remove the left-whitespace margin of a block of Python code."""
+
+ state = [False, False]
+ (backslashed, triplequoted) = (0, 1)
+
+ def in_multi_line(line):
+ start_state = (state[backslashed] or state[triplequoted])
+
+ if re.search(r"\\$", line):
+ state[backslashed] = True
+ else:
+ state[backslashed] = False
+
+ def match(reg, t):
+ m = re.match(reg, t)
+ if m:
+ return m, t[len(m.group(0)):]
+ else:
+ return None, t
+
+ while line:
+ if state[triplequoted]:
+ m, line = match(r"%s" % state[triplequoted], line)
+ if m:
+ state[triplequoted] = False
+ else:
+ m, line = match(r".*?(?=%s|$)" % state[triplequoted], line)
+ else:
+ m, line = match(r'#', line)
+ if m:
+ return start_state
+
+ m, line = match(r"\"\"\"|\'\'\'", line)
+ if m:
+ state[triplequoted] = m.group(0)
+ continue
+
+ m, line = match(r".*?(?=\"\"\"|\'\'\'|#|$)", line)
+
+ return start_state
+
+ def _indent_line(line, stripspace = ''):
+ return re.sub(r"^%s" % stripspace, '', line)
+
+ lines = []
+ stripspace = None
+
+ for line in re.split(r'\r?\n', text):
+ if in_multi_line(line):
+ lines.append(line)
+ else:
+ line = line.expandtabs()
+ if stripspace is None and re.search(r"^[ \t]*[^# \t]", line):
+ stripspace = re.match(r"^([ \t]*)", line).group(1)
+ lines.append(_indent_line(line, stripspace))
+ return "\n".join(lines)
diff --git a/mako/pyparser.py b/mako/pyparser.py
new file mode 100644
index 00000000..953596af
--- /dev/null
+++ b/mako/pyparser.py
@@ -0,0 +1,533 @@
+# mako/pyparser.py
+# Copyright (C) 2006-2011 the Mako authors and contributors
+#
+# This module is part of Mako and is released under
+# the MIT License: http://www.opensource.org/licenses/mit-license.php
+
+"""Handles parsing of Python code.
+
+Parsing to AST is done via _ast on Python > 2.5, otherwise the compiler
+module is used.
+"""
+
+from StringIO import StringIO
+from mako import exceptions, util
+import operator
+
+if util.py3k:
+ # words that cannot be assigned to (notably
+ # smaller than the total keys in __builtins__)
+ reserved = set(['True', 'False', 'None', 'print'])
+
+ # the "id" attribute on a function node
+ arg_id = operator.attrgetter('arg')
+else:
+ # words that cannot be assigned to (notably
+ # smaller than the total keys in __builtins__)
+ reserved = set(['True', 'False', 'None'])
+
+ # the "id" attribute on a function node
+ arg_id = operator.attrgetter('id')
+
+
+try:
+ import _ast
+ util.restore__ast(_ast)
+ import _ast_util
+except ImportError:
+ _ast = None
+ from compiler import parse as compiler_parse
+ from compiler import visitor
+
+
+def parse(code, mode='exec', **exception_kwargs):
+ """Parse an expression into AST"""
+
+
+ try:
+ if _ast:
+ return _ast_util.parse(code, '', mode)
+ else:
+ if isinstance(code, unicode):
+ code = code.encode('ascii', 'backslashreplace')
+ return compiler_parse(code, mode)
+ except Exception, e:
+ raise exceptions.SyntaxException(
+ "(%s) %s (%r)" % (
+ e.__class__.__name__,
+ e,
+ code[0:50]
+ ), **exception_kwargs)
+
+
+if _ast:
+ class FindIdentifiers(_ast_util.NodeVisitor):
+
+ def __init__(self, listener, **exception_kwargs):
+ self.in_function = False
+ self.in_assign_targets = False
+ self.local_ident_stack = {}
+ self.listener = listener
+ self.exception_kwargs = exception_kwargs
+
+ def _add_declared(self, name):
+ if not self.in_function:
+ self.listener.declared_identifiers.add(name)
+
+ def visit_ClassDef(self, node):
+ self._add_declared(node.name)
+
+ def visit_Assign(self, node):
+
+ # flip around the visiting of Assign so the expression gets
+ # evaluated first, in the case of a clause like "x=x+5" (x
+ # is undeclared)
+
+ self.visit(node.value)
+ in_a = self.in_assign_targets
+ self.in_assign_targets = True
+ for n in node.targets:
+ self.visit(n)
+ self.in_assign_targets = in_a
+
+ if util.py3k:
+
+ # ExceptHandler is in Python 2, but this block only works in
+ # Python 3 (and is required there)
+
+ def visit_ExceptHandler(self, node):
+ if node.name is not None:
+ self._add_declared(node.name)
+ if node.type is not None:
+ self.listener.undeclared_identifiers.add(node.type.id)
+ for statement in node.body:
+ self.visit(statement)
+
+ def visit_Lambda(self, node, *args):
+ self._visit_function(node, True)
+
+ def visit_FunctionDef(self, node):
+ self._add_declared(node.name)
+ self._visit_function(node, False)
+
+ def _visit_function(self, node, islambda):
+
+ # push function state onto stack. dont log any more
+ # identifiers as "declared" until outside of the function,
+ # but keep logging identifiers as "undeclared". track
+ # argument names in each function header so they arent
+ # counted as "undeclared"
+
+ saved = {}
+ inf = self.in_function
+ self.in_function = True
+ for arg in node.args.args:
+ if arg_id(arg) in self.local_ident_stack:
+ saved[arg_id(arg)] = True
+ else:
+ self.local_ident_stack[arg_id(arg)] = True
+ if islambda:
+ self.visit(node.body)
+ else:
+ for n in node.body:
+ self.visit(n)
+ self.in_function = inf
+ for arg in node.args.args:
+ if arg_id(arg) not in saved:
+ del self.local_ident_stack[arg_id(arg)]
+
+ def visit_For(self, node):
+
+ # flip around visit
+
+ self.visit(node.iter)
+ self.visit(node.target)
+ for statement in node.body:
+ self.visit(statement)
+ for statement in node.orelse:
+ self.visit(statement)
+
+ def visit_Name(self, node):
+ if isinstance(node.ctx, _ast.Store):
+ self._add_declared(node.id)
+ if node.id not in reserved and node.id \
+ not in self.listener.declared_identifiers and node.id \
+ not in self.local_ident_stack:
+ self.listener.undeclared_identifiers.add(node.id)
+
+ def visit_Import(self, node):
+ for name in node.names:
+ if name.asname is not None:
+ self._add_declared(name.asname)
+ else:
+ self._add_declared(name.name.split('.')[0])
+
+ def visit_ImportFrom(self, node):
+ for name in node.names:
+ if name.asname is not None:
+ self._add_declared(name.asname)
+ else:
+ if name.name == '*':
+ raise exceptions.CompileException(
+ "'import *' is not supported, since all identifier "
+ "names must be explicitly declared. Please use the "
+ "form 'from import , , "
+ "...' instead.", **self.exception_kwargs)
+ self._add_declared(name.name)
+
+
+ class FindTuple(_ast_util.NodeVisitor):
+
+ def __init__(self, listener, code_factory, **exception_kwargs):
+ self.listener = listener
+ self.exception_kwargs = exception_kwargs
+ self.code_factory = code_factory
+
+ def visit_Tuple(self, node):
+ for n in node.elts:
+ p = self.code_factory(n, **self.exception_kwargs)
+ self.listener.codeargs.append(p)
+ self.listener.args.append(ExpressionGenerator(n).value())
+ self.listener.declared_identifiers = \
+ self.listener.declared_identifiers.union(
+ p.declared_identifiers)
+ self.listener.undeclared_identifiers = \
+ self.listener.undeclared_identifiers.union(
+ p.undeclared_identifiers)
+
+
+ class ParseFunc(_ast_util.NodeVisitor):
+
+ def __init__(self, listener, **exception_kwargs):
+ self.listener = listener
+ self.exception_kwargs = exception_kwargs
+
+ def visit_FunctionDef(self, node):
+ self.listener.funcname = node.name
+ argnames = [arg_id(arg) for arg in node.args.args]
+ if node.args.vararg:
+ argnames.append(node.args.vararg)
+ if node.args.kwarg:
+ argnames.append(node.args.kwarg)
+ self.listener.argnames = argnames
+ self.listener.defaults = node.args.defaults # ast
+ self.listener.varargs = node.args.vararg
+ self.listener.kwargs = node.args.kwarg
+
+
+ class ExpressionGenerator(object):
+
+ def __init__(self, astnode):
+ self.generator = _ast_util.SourceGenerator(' ' * 4)
+ self.generator.visit(astnode)
+
+ def value(self):
+ return ''.join(self.generator.result)
+else:
+ class FindIdentifiers(object):
+
+ def __init__(self, listener, **exception_kwargs):
+ self.in_function = False
+ self.local_ident_stack = {}
+ self.listener = listener
+ self.exception_kwargs = exception_kwargs
+
+ def _add_declared(self, name):
+ if not self.in_function:
+ self.listener.declared_identifiers.add(name)
+
+ def visitClass(self, node, *args):
+ self._add_declared(node.name)
+
+ def visitAssName(self, node, *args):
+ self._add_declared(node.name)
+
+ def visitAssign(self, node, *args):
+
+ # flip around the visiting of Assign so the expression gets
+ # evaluated first, in the case of a clause like "x=x+5" (x
+ # is undeclared)
+
+ self.visit(node.expr, *args)
+ for n in node.nodes:
+ self.visit(n, *args)
+
+ def visitLambda(self, node, *args):
+ self._visit_function(node, args)
+
+ def visitFunction(self, node, *args):
+ self._add_declared(node.name)
+ self._visit_function(node, args)
+
+ def _visit_function(self, node, args):
+
+ # push function state onto stack. dont log any more
+ # identifiers as "declared" until outside of the function,
+ # but keep logging identifiers as "undeclared". track
+ # argument names in each function header so they arent
+ # counted as "undeclared"
+
+ saved = {}
+ inf = self.in_function
+ self.in_function = True
+ for arg in node.argnames:
+ if arg in self.local_ident_stack:
+ saved[arg] = True
+ else:
+ self.local_ident_stack[arg] = True
+ for n in node.getChildNodes():
+ self.visit(n, *args)
+ self.in_function = inf
+ for arg in node.argnames:
+ if arg not in saved:
+ del self.local_ident_stack[arg]
+
+ def visitFor(self, node, *args):
+
+ # flip around visit
+
+ self.visit(node.list, *args)
+ self.visit(node.assign, *args)
+ self.visit(node.body, *args)
+
+ def visitName(self, node, *args):
+ if node.name not in reserved and node.name \
+ not in self.listener.declared_identifiers and node.name \
+ not in self.local_ident_stack:
+ self.listener.undeclared_identifiers.add(node.name)
+
+ def visitImport(self, node, *args):
+ for mod, alias in node.names:
+ if alias is not None:
+ self._add_declared(alias)
+ else:
+ self._add_declared(mod.split('.')[0])
+
+ def visitFrom(self, node, *args):
+ for mod, alias in node.names:
+ if alias is not None:
+ self._add_declared(alias)
+ else:
+ if mod == '*':
+ raise exceptions.CompileException(
+ "'import *' is not supported, since all identifier "
+ "names must be explicitly declared. Please use the "
+ "form 'from import , , "
+ "...' instead.", **self.exception_kwargs)
+ self._add_declared(mod)
+
+ def visit(self, expr):
+ visitor.walk(expr, self) # , walker=walker())
+
+
+ class FindTuple(object):
+
+ def __init__(self, listener, code_factory, **exception_kwargs):
+ self.listener = listener
+ self.exception_kwargs = exception_kwargs
+ self.code_factory = code_factory
+
+ def visitTuple(self, node, *args):
+ for n in node.nodes:
+ p = self.code_factory(n, **self.exception_kwargs)
+ self.listener.codeargs.append(p)
+ self.listener.args.append(ExpressionGenerator(n).value())
+ self.listener.declared_identifiers = \
+ self.listener.declared_identifiers.union(p.declared_identifiers)
+ self.listener.undeclared_identifiers = \
+ self.listener.undeclared_identifiers.union(p.undeclared_identifiers)
+
+ def visit(self, expr):
+ visitor.walk(expr, self) # , walker=walker())
+
+
+ class ParseFunc(object):
+
+ def __init__(self, listener, **exception_kwargs):
+ self.listener = listener
+ self.exception_kwargs = exception_kwargs
+
+ def visitFunction(self, node, *args):
+ self.listener.funcname = node.name
+ self.listener.argnames = node.argnames
+ self.listener.defaults = node.defaults
+ self.listener.varargs = node.varargs
+ self.listener.kwargs = node.kwargs
+
+ def visit(self, expr):
+ visitor.walk(expr, self)
+
+
+ class ExpressionGenerator(object):
+
+ """given an AST node, generates an equivalent literal Python
+ expression."""
+
+ def __init__(self, astnode):
+ self.buf = StringIO()
+ visitor.walk(astnode, self) # , walker=walker())
+
+ def value(self):
+ return self.buf.getvalue()
+
+ def operator(self, op, node, *args):
+ self.buf.write('(')
+ self.visit(node.left, *args)
+ self.buf.write(' %s ' % op)
+ self.visit(node.right, *args)
+ self.buf.write(')')
+
+ def booleanop(self, op, node, *args):
+ self.visit(node.nodes[0])
+ for n in node.nodes[1:]:
+ self.buf.write(' ' + op + ' ')
+ self.visit(n, *args)
+
+ def visitConst(self, node, *args):
+ self.buf.write(repr(node.value))
+
+ def visitAssName(self, node, *args):
+
+ # TODO: figure out OP_ASSIGN, other OP_s
+
+ self.buf.write(node.name)
+
+ def visitName(self, node, *args):
+ self.buf.write(node.name)
+
+ def visitMul(self, node, *args):
+ self.operator('*', node, *args)
+
+ def visitAnd(self, node, *args):
+ self.booleanop('and', node, *args)
+
+ def visitOr(self, node, *args):
+ self.booleanop('or', node, *args)
+
+ def visitBitand(self, node, *args):
+ self.booleanop('&', node, *args)
+
+ def visitBitor(self, node, *args):
+ self.booleanop('|', node, *args)
+
+ def visitBitxor(self, node, *args):
+ self.booleanop('^', node, *args)
+
+ def visitAdd(self, node, *args):
+ self.operator('+', node, *args)
+
+ def visitGetattr(self, node, *args):
+ self.visit(node.expr, *args)
+ self.buf.write('.%s' % node.attrname)
+
+ def visitSub(self, node, *args):
+ self.operator('-', node, *args)
+
+ def visitNot(self, node, *args):
+ self.buf.write('not ')
+ self.visit(node.expr)
+
+ def visitDiv(self, node, *args):
+ self.operator('/', node, *args)
+
+ def visitFloorDiv(self, node, *args):
+ self.operator('//', node, *args)
+
+ def visitSubscript(self, node, *args):
+ self.visit(node.expr)
+ self.buf.write('[')
+ [self.visit(x) for x in node.subs]
+ self.buf.write(']')
+
+ def visitUnarySub(self, node, *args):
+ self.buf.write('-')
+ self.visit(node.expr)
+
+ def visitUnaryAdd(self, node, *args):
+ self.buf.write('-')
+ self.visit(node.expr)
+
+ def visitSlice(self, node, *args):
+ self.visit(node.expr)
+ self.buf.write('[')
+ if node.lower is not None:
+ self.visit(node.lower)
+ self.buf.write(':')
+ if node.upper is not None:
+ self.visit(node.upper)
+ self.buf.write(']')
+
+ def visitDict(self, node):
+ self.buf.write('{')
+ c = node.getChildren()
+ for i in range(0, len(c), 2):
+ self.visit(c[i])
+ self.buf.write(': ')
+ self.visit(c[i + 1])
+ if i < len(c) - 2:
+ self.buf.write(', ')
+ self.buf.write('}')
+
+ def visitTuple(self, node):
+ self.buf.write('(')
+ c = node.getChildren()
+ for i in range(0, len(c)):
+ self.visit(c[i])
+ if i < len(c) - 1:
+ self.buf.write(', ')
+ self.buf.write(')')
+
+ def visitList(self, node):
+ self.buf.write('[')
+ c = node.getChildren()
+ for i in range(0, len(c)):
+ self.visit(c[i])
+ if i < len(c) - 1:
+ self.buf.write(', ')
+ self.buf.write(']')
+
+ def visitListComp(self, node):
+ self.buf.write('[')
+ self.visit(node.expr)
+ self.buf.write(' ')
+ for n in node.quals:
+ self.visit(n)
+ self.buf.write(']')
+
+ def visitListCompFor(self, node):
+ self.buf.write(' for ')
+ self.visit(node.assign)
+ self.buf.write(' in ')
+ self.visit(node.list)
+ for n in node.ifs:
+ self.visit(n)
+
+ def visitListCompIf(self, node):
+ self.buf.write(' if ')
+ self.visit(node.test)
+
+ def visitCompare(self, node):
+ self.visit(node.expr)
+ for tup in node.ops:
+ self.buf.write(tup[0])
+ self.visit(tup[1])
+
+ def visitCallFunc(self, node, *args):
+ self.visit(node.node)
+ self.buf.write('(')
+ if len(node.args):
+ self.visit(node.args[0])
+ for a in node.args[1:]:
+ self.buf.write(', ')
+ self.visit(a)
+ self.buf.write(')')
+
+
+ class walker(visitor.ASTVisitor):
+
+ def dispatch(self, node, *args):
+ print 'Node:', str(node)
+
+ # print "dir:", dir(node)
+
+ return visitor.ASTVisitor.dispatch(self, node, *args)
diff --git a/mako/runtime.py b/mako/runtime.py
new file mode 100644
index 00000000..dfd701aa
--- /dev/null
+++ b/mako/runtime.py
@@ -0,0 +1,735 @@
+# mako/runtime.py
+# Copyright (C) 2006-2011 the Mako authors and contributors
+#
+# This module is part of Mako and is released under
+# the MIT License: http://www.opensource.org/licenses/mit-license.php
+
+"""provides runtime services for templates, including Context,
+Namespace, and various helper functions."""
+
+from mako import exceptions, util
+import __builtin__, inspect, sys
+
+class Context(object):
+ """Provides runtime namespace, output buffer, and various
+ callstacks for templates.
+
+ See :ref:`runtime_toplevel` for detail on the usage of
+ :class:`.Context`.
+
+ """
+
+ def __init__(self, buffer, **data):
+ self._buffer_stack = [buffer]
+
+ self._data = data
+ self._kwargs = data.copy()
+ self._with_template = None
+ self._outputting_as_unicode = None
+ self.namespaces = {}
+
+ # "capture" function which proxies to the
+ # generic "capture" function
+ self._data['capture'] = util.partial(capture, self)
+
+ # "caller" stack used by def calls with content
+ self.caller_stack = self._data['caller'] = CallerStack()
+
+ @property
+ def lookup(self):
+ """Return the :class:`.TemplateLookup` associated
+ with this :class:`.Context`.
+
+ """
+ return self._with_template.lookup
+
+ @property
+ def kwargs(self):
+ """Return the dictionary of keyword argments associated with this
+ :class:`.Context`.
+
+ """
+ return self._kwargs.copy()
+
+ def push_caller(self, caller):
+ """Pushes a 'caller' callable onto the callstack for
+ this :class:`.Context`."""
+
+
+ self.caller_stack.append(caller)
+
+ def pop_caller(self):
+ """Pops a 'caller' callable onto the callstack for this
+ :class:`.Context`."""
+
+ del self.caller_stack[-1]
+
+ def keys(self):
+ """Return a list of all names established in this :class:`.Context`."""
+
+ return self._data.keys()
+
+ def __getitem__(self, key):
+ if key in self._data:
+ return self._data[key]
+ else:
+ return __builtin__.__dict__[key]
+
+ def _push_writer(self):
+ """push a capturing buffer onto this Context and return
+ the new writer function."""
+
+ buf = util.FastEncodingBuffer()
+ self._buffer_stack.append(buf)
+ return buf.write
+
+ def _pop_buffer_and_writer(self):
+ """pop the most recent capturing buffer from this Context
+ and return the current writer after the pop.
+
+ """
+
+ buf = self._buffer_stack.pop()
+ return buf, self._buffer_stack[-1].write
+
+ def _push_buffer(self):
+ """push a capturing buffer onto this Context."""
+
+ self._push_writer()
+
+ def _pop_buffer(self):
+ """pop the most recent capturing buffer from this Context."""
+
+ return self._buffer_stack.pop()
+
+ def get(self, key, default=None):
+ """Return a value from this :class:`.Context`."""
+
+ return self._data.get(key,
+ __builtin__.__dict__.get(key, default)
+ )
+
+ def write(self, string):
+ """Write a string to this :class:`.Context` object's
+ underlying output buffer."""
+
+ self._buffer_stack[-1].write(string)
+
+ def writer(self):
+ """Return the current writer function"""
+
+ return self._buffer_stack[-1].write
+
+ def _copy(self):
+ c = Context.__new__(Context)
+ c._buffer_stack = self._buffer_stack
+ c._data = self._data.copy()
+ c._kwargs = self._kwargs
+ c._with_template = self._with_template
+ c._outputting_as_unicode = self._outputting_as_unicode
+ c.namespaces = self.namespaces
+ c.caller_stack = self.caller_stack
+ return c
+
+ def locals_(self, d):
+ """create a new :class:`.Context` with a copy of this
+ :class:`Context`'s current state, updated with the given dictionary."""
+
+ if len(d) == 0:
+ return self
+ c = self._copy()
+ c._data.update(d)
+ return c
+
+ def _clean_inheritance_tokens(self):
+ """create a new copy of this :class:`.Context`. with
+ tokens related to inheritance state removed."""
+
+ c = self._copy()
+ x = c._data
+ x.pop('self', None)
+ x.pop('parent', None)
+ x.pop('next', None)
+ return c
+
+class CallerStack(list):
+ def __init__(self):
+ self.nextcaller = None
+ def __nonzero__(self):
+ return self._get_caller() and True or False
+ def _get_caller(self):
+ return self[-1]
+ def __getattr__(self, key):
+ return getattr(self._get_caller(), key)
+ def _push_frame(self):
+ self.append(self.nextcaller or None)
+ self.nextcaller = None
+ def _pop_frame(self):
+ self.nextcaller = self.pop()
+
+
+class Undefined(object):
+ """Represents an undefined value in a template.
+
+ All template modules have a constant value
+ ``UNDEFINED`` present which is an instance of this
+ object.
+
+ """
+ def __str__(self):
+ raise NameError("Undefined")
+ def __nonzero__(self):
+ return False
+
+UNDEFINED = Undefined()
+
+class _NSAttr(object):
+ def __init__(self, parent):
+ self.__parent = parent
+ def __getattr__(self, key):
+ ns = self.__parent
+ while ns:
+ if hasattr(ns.module, key):
+ return getattr(ns.module, key)
+ else:
+ ns = ns.inherits
+ raise AttributeError(key)
+
+class Namespace(object):
+ """Provides access to collections of rendering methods, which
+ can be local, from other templates, or from imported modules.
+
+ To access a particular rendering method referenced by a
+ :class:`.Namespace`, use plain attribute access::
+
+ ${some_namespace.foo(x, y, z)}
+
+ :class:`.Namespace` also contains several built-in attributes
+ described here.
+
+ """
+
+ def __init__(self, name, context,
+ callables=None, inherits=None,
+ populate_self=True, calling_uri=None):
+ self.name = name
+ self.context = context
+ self.inherits = inherits
+ if callables is not None:
+ self.callables = dict([(c.func_name, c) for c in callables])
+
+ callables = ()
+
+ module = None
+ """The Python module referenced by this Namespace.
+
+ If the namespace references a :class:`.Template`, then
+ this module is the equivalent of ``template.module``,
+ i.e. the generated module for the template.
+
+ """
+
+ template = None
+ """The :class:`.Template` object referenced by this
+ :class:`.Namespace`, if any.
+
+ """
+
+ context = None
+ """The :class:`.Context` object for this namespace.
+
+ Namespaces are often created with copies of contexts that
+ contain slightly different data, particularly in inheritance
+ scenarios. Using the :class:`.Context` off of a :class:`.Namespace` one
+ can traverse an entire chain of templates that inherit from
+ one-another.
+
+ """
+
+ filename = None
+ """The path of the filesystem file used for this
+ Namespace's module or template.
+
+ If this is a pure module-based
+ Namespace, this evaluates to ``module.__file__``. If a
+ template-based namespace, it evaluates to the original
+ template file location.
+
+ """
+
+ uri = None
+ """The uri for this Namespace's template.
+
+ I.e. whatever was sent to :meth:`.TemplateLookup.get_template()`.
+
+ This is the equivalent of :attr:`Template.uri`.
+
+ """
+
+ _templateuri = None
+
+ @util.memoized_property
+ def attr(self):
+ """Access module level attributes by name.
+
+ This accessor allows templates to supply "scalar"
+ attributes which are particularly handy in inheritance
+ relationships. See the example in
+ :ref:`inheritance_toplevel`.
+
+ """
+ return _NSAttr(self)
+
+ def get_namespace(self, uri):
+ """Return a :class:`.Namespace` corresponding to the given uri.
+
+ If the given uri is a relative uri (i.e. it does not
+ contain ia leading slash ``/``), the uri is adjusted to
+ be relative to the uri of the namespace itself. This
+ method is therefore mostly useful off of the built-in
+ ``local`` namespace, described in :ref:`namespace_local`
+
+ In
+ most cases, a template wouldn't need this function, and
+ should instead use the ``<%namespace>`` tag to load
+ namespaces. However, since all ``<%namespace>`` tags are
+ evaulated before the body of a template ever runs,
+ this method can be used to locate namespaces using
+ expressions that were generated within the body code of
+ the template, or to conditionally use a particular
+ namespace.
+
+ """
+ key = (self, uri)
+ if key in self.context.namespaces:
+ return self.context.namespaces[key]
+ else:
+ ns = TemplateNamespace(uri, self.context._copy(),
+ templateuri=uri,
+ calling_uri=self._templateuri)
+ self.context.namespaces[key] = ns
+ return ns
+
+ def get_template(self, uri):
+ """Return a :class:`.Template` from the given uri.
+
+ The uri resolution is relative to the uri of this :class:`.Namespace`
+ object's :class:`.Template`.
+
+ """
+ return _lookup_template(self.context, uri, self._templateuri)
+
+ def get_cached(self, key, **kwargs):
+ """Return a value from the :class:`.Cache` referenced by this
+ :class:`.Namespace` object's :class:`.Template`.
+
+ The advantage to this method versus direct access to the
+ :class:`.Cache` is that the configuration parameters
+ declared in ``<%page>`` take effect here, thereby calling
+ up the same configured backend as that configured
+ by ``<%page>``.
+
+ """
+
+ if self.template:
+ if not self.template.cache_enabled:
+ createfunc = kwargs.get('createfunc', None)
+ if createfunc:
+ return createfunc()
+ else:
+ return None
+
+ if self.template.cache_dir:
+ kwargs.setdefault('data_dir', self.template.cache_dir)
+ if self.template.cache_type:
+ kwargs.setdefault('type', self.template.cache_type)
+ if self.template.cache_url:
+ kwargs.setdefault('url', self.template.cache_url)
+ return self.cache.get(key, **kwargs)
+
+ @property
+ def cache(self):
+ """Return the :class:`.Cache` object referenced
+ by this :class:`.Namespace` object's
+ :class:`.Template`.
+
+ """
+ return self.template.cache
+
+ def include_file(self, uri, **kwargs):
+ """Include a file at the given uri"""
+
+ _include_file(self.context, uri, self._templateuri, **kwargs)
+
+ def _populate(self, d, l):
+ for ident in l:
+ if ident == '*':
+ for (k, v) in self._get_star():
+ d[k] = v
+ else:
+ d[ident] = getattr(self, ident)
+
+ def _get_star(self):
+ if self.callables:
+ for key in self.callables:
+ yield (key, self.callables[key])
+
+ def __getattr__(self, key):
+ if key in self.callables:
+ val = self.callables[key]
+ elif self.inherits:
+ val = getattr(self.inherits, key)
+ else:
+ raise AttributeError(
+ "Namespace '%s' has no member '%s'" %
+ (self.name, key))
+ setattr(self, key, val)
+ return val
+
+class TemplateNamespace(Namespace):
+ """A :class:`.Namespace` specific to a :class:`.Template` instance."""
+
+ def __init__(self, name, context, template=None, templateuri=None,
+ callables=None, inherits=None,
+ populate_self=True, calling_uri=None):
+ self.name = name
+ self.context = context
+ self.inherits = inherits
+ if callables is not None:
+ self.callables = dict([(c.func_name, c) for c in callables])
+
+ if templateuri is not None:
+ self.template = _lookup_template(context, templateuri,
+ calling_uri)
+ self._templateuri = self.template.module._template_uri
+ elif template is not None:
+ self.template = template
+ self._templateuri = template.module._template_uri
+ else:
+ raise TypeError("'template' argument is required.")
+
+ if populate_self:
+ lclcallable, lclcontext = \
+ _populate_self_namespace(context, self.template,
+ self_ns=self)
+
+ @property
+ def module(self):
+ """The Python module referenced by this Namespace.
+
+ If the namespace references a :class:`.Template`, then
+ this module is the equivalent of ``template.module``,
+ i.e. the generated module for the template.
+
+ """
+ return self.template.module
+
+ @property
+ def filename(self):
+ """The path of the filesystem file used for this
+ Namespace's module or template.
+ """
+ return self.template.filename
+
+ @property
+ def uri(self):
+ """The uri for this Namespace's template.
+
+ I.e. whatever was sent to :meth:`.TemplateLookup.get_template()`.
+
+ This is the equivalent of :attr:`Template.uri`.
+
+ """
+ return self.template.uri
+
+ def _get_star(self):
+ if self.callables:
+ for key in self.callables:
+ yield (key, self.callables[key])
+ def get(key):
+ callable_ = self.template._get_def_callable(key)
+ return util.partial(callable_, self.context)
+ for k in self.template.module._exports:
+ yield (k, get(k))
+
+ def __getattr__(self, key):
+ if key in self.callables:
+ val = self.callables[key]
+ elif self.template.has_def(key):
+ callable_ = self.template._get_def_callable(key)
+ val = util.partial(callable_, self.context)
+ elif self.inherits:
+ val = getattr(self.inherits, key)
+
+ else:
+ raise AttributeError(
+ "Namespace '%s' has no member '%s'" %
+ (self.name, key))
+ setattr(self, key, val)
+ return val
+
+class ModuleNamespace(Namespace):
+ """A :class:`.Namespace` specific to a Python module instance."""
+
+ def __init__(self, name, context, module,
+ callables=None, inherits=None,
+ populate_self=True, calling_uri=None):
+ self.name = name
+ self.context = context
+ self.inherits = inherits
+ if callables is not None:
+ self.callables = dict([(c.func_name, c) for c in callables])
+
+ mod = __import__(module)
+ for token in module.split('.')[1:]:
+ mod = getattr(mod, token)
+ self.module = mod
+
+ @property
+ def filename(self):
+ """The path of the filesystem file used for this
+ Namespace's module or template.
+ """
+ return self.module.__file__
+
+ def _get_star(self):
+ if self.callables:
+ for key in self.callables:
+ yield (key, self.callables[key])
+ def get(key):
+ callable_ = getattr(self.module, key)
+ return util.partial(callable_, self.context)
+ for k in dir(self.module):
+ if k[0] != '_':
+ yield (k, get(k))
+
+ def __getattr__(self, key):
+ if key in self.callables:
+ val = self.callables[key]
+ elif hasattr(self.module, key):
+ callable_ = getattr(self.module, key)
+ val = util.partial(callable_, self.context)
+ elif self.inherits:
+ val = getattr(self.inherits, key)
+ else:
+ raise AttributeError(
+ "Namespace '%s' has no member '%s'" %
+ (self.name, key))
+ setattr(self, key, val)
+ return val
+
+def supports_caller(func):
+ """Apply a caller_stack compatibility decorator to a plain
+ Python function.
+
+ See the example in :ref:`namespaces_python_modules`.
+
+ """
+
+ def wrap_stackframe(context, *args, **kwargs):
+ context.caller_stack._push_frame()
+ try:
+ return func(context, *args, **kwargs)
+ finally:
+ context.caller_stack._pop_frame()
+ return wrap_stackframe
+
+def capture(context, callable_, *args, **kwargs):
+ """Execute the given template def, capturing the output into
+ a buffer.
+
+ See the example in :ref:`namespaces_python_modules`.
+
+ """
+
+ if not callable(callable_):
+ raise exceptions.RuntimeException(
+ "capture() function expects a callable as "
+ "its argument (i.e. capture(func, *args, **kwargs))"
+ )
+ context._push_buffer()
+ try:
+ callable_(*args, **kwargs)
+ finally:
+ buf = context._pop_buffer()
+ return buf.getvalue()
+
+def _decorate_toplevel(fn):
+ def decorate_render(render_fn):
+ def go(context, *args, **kw):
+ def y(*args, **kw):
+ return render_fn(context, *args, **kw)
+ try:
+ y.__name__ = render_fn.__name__[7:]
+ except TypeError:
+ # < Python 2.4
+ pass
+ return fn(y)(context, *args, **kw)
+ return go
+ return decorate_render
+
+def _decorate_inline(context, fn):
+ def decorate_render(render_fn):
+ dec = fn(render_fn)
+ def go(*args, **kw):
+ return dec(context, *args, **kw)
+ return go
+ return decorate_render
+
+def _include_file(context, uri, calling_uri, **kwargs):
+ """locate the template from the given uri and include it in
+ the current output."""
+
+ template = _lookup_template(context, uri, calling_uri)
+ (callable_, ctx) = _populate_self_namespace(
+ context._clean_inheritance_tokens(),
+ template)
+ callable_(ctx, **_kwargs_for_include(callable_, context._data, **kwargs))
+
+def _inherit_from(context, uri, calling_uri):
+ """called by the _inherit method in template modules to set
+ up the inheritance chain at the start of a template's
+ execution."""
+
+ if uri is None:
+ return None
+ template = _lookup_template(context, uri, calling_uri)
+ self_ns = context['self']
+ ih = self_ns
+ while ih.inherits is not None:
+ ih = ih.inherits
+ lclcontext = context.locals_({'next':ih})
+ ih.inherits = TemplateNamespace("self:%s" % template.uri,
+ lclcontext,
+ template = template,
+ populate_self=False)
+ context._data['parent'] = lclcontext._data['local'] = ih.inherits
+ callable_ = getattr(template.module, '_mako_inherit', None)
+ if callable_ is not None:
+ ret = callable_(template, lclcontext)
+ if ret:
+ return ret
+
+ gen_ns = getattr(template.module, '_mako_generate_namespaces', None)
+ if gen_ns is not None:
+ gen_ns(context)
+ return (template.callable_, lclcontext)
+
+def _lookup_template(context, uri, relativeto):
+ lookup = context._with_template.lookup
+ if lookup is None:
+ raise exceptions.TemplateLookupException(
+ "Template '%s' has no TemplateLookup associated" %
+ context._with_template.uri)
+ uri = lookup.adjust_uri(uri, relativeto)
+ try:
+ return lookup.get_template(uri)
+ except exceptions.TopLevelLookupException, e:
+ raise exceptions.TemplateLookupException(str(e))
+
+def _populate_self_namespace(context, template, self_ns=None):
+ if self_ns is None:
+ self_ns = TemplateNamespace('self:%s' % template.uri,
+ context, template=template,
+ populate_self=False)
+ context._data['self'] = context._data['local'] = self_ns
+ if hasattr(template.module, '_mako_inherit'):
+ ret = template.module._mako_inherit(template, context)
+ if ret:
+ return ret
+ return (template.callable_, context)
+
+def _render(template, callable_, args, data, as_unicode=False):
+ """create a Context and return the string
+ output of the given template and template callable."""
+
+ if as_unicode:
+ buf = util.FastEncodingBuffer(unicode=True)
+ elif template.bytestring_passthrough:
+ buf = util.StringIO()
+ else:
+ buf = util.FastEncodingBuffer(
+ unicode=as_unicode,
+ encoding=template.output_encoding,
+ errors=template.encoding_errors)
+ context = Context(buf, **data)
+ context._outputting_as_unicode = as_unicode
+ context._with_template = template
+
+ _render_context(template, callable_, context, *args,
+ **_kwargs_for_callable(callable_, data))
+ return context._pop_buffer().getvalue()
+
+def _kwargs_for_callable(callable_, data):
+ argspec = util.inspect_func_args(callable_)
+ # for normal pages, **pageargs is usually present
+ if argspec[2]:
+ return data
+
+ # for rendering defs from the top level, figure out the args
+ namedargs = argspec[0] + [v for v in argspec[1:3] if v is not None]
+ kwargs = {}
+ for arg in namedargs:
+ if arg != 'context' and arg in data and arg not in kwargs:
+ kwargs[arg] = data[arg]
+ return kwargs
+
+def _kwargs_for_include(callable_, data, **kwargs):
+ argspec = util.inspect_func_args(callable_)
+ namedargs = argspec[0] + [v for v in argspec[1:3] if v is not None]
+ for arg in namedargs:
+ if arg != 'context' and arg in data and arg not in kwargs:
+ kwargs[arg] = data[arg]
+ return kwargs
+
+def _render_context(tmpl, callable_, context, *args, **kwargs):
+ import mako.template as template
+ # create polymorphic 'self' namespace for this
+ # template with possibly updated context
+ if not isinstance(tmpl, template.DefTemplate):
+ # if main render method, call from the base of the inheritance stack
+ (inherit, lclcontext) = _populate_self_namespace(context, tmpl)
+ _exec_template(inherit, lclcontext, args=args, kwargs=kwargs)
+ else:
+ # otherwise, call the actual rendering method specified
+ (inherit, lclcontext) = _populate_self_namespace(context, tmpl.parent)
+ _exec_template(callable_, context, args=args, kwargs=kwargs)
+
+def _exec_template(callable_, context, args=None, kwargs=None):
+ """execute a rendering callable given the callable, a
+ Context, and optional explicit arguments
+
+ the contextual Template will be located if it exists, and
+ the error handling options specified on that Template will
+ be interpreted here.
+ """
+ template = context._with_template
+ if template is not None and \
+ (template.format_exceptions or template.error_handler):
+ error = None
+ try:
+ callable_(context, *args, **kwargs)
+ except Exception, e:
+ _render_error(template, context, e)
+ except:
+ e = sys.exc_info()[0]
+ _render_error(template, context, e)
+ else:
+ callable_(context, *args, **kwargs)
+
+def _render_error(template, context, error):
+ if template.error_handler:
+ result = template.error_handler(context, error)
+ if not result:
+ raise error
+ else:
+ error_template = exceptions.html_error_template()
+ if context._outputting_as_unicode:
+ context._buffer_stack[:] = [util.FastEncodingBuffer(unicode=True)]
+ else:
+ context._buffer_stack[:] = [util.FastEncodingBuffer(
+ error_template.output_encoding,
+ error_template.encoding_errors)]
+
+ context._with_template = error_template
+ error_template.render_context(context, error=error)
diff --git a/mako/template.py b/mako/template.py
new file mode 100644
index 00000000..903dc425
--- /dev/null
+++ b/mako/template.py
@@ -0,0 +1,536 @@
+# mako/template.py
+# Copyright (C) 2006-2011 the Mako authors and contributors
+#
+# This module is part of Mako and is released under
+# the MIT License: http://www.opensource.org/licenses/mit-license.php
+
+"""Provides the Template class, a facade for parsing, generating and executing
+template strings, as well as template runtime operations."""
+
+from mako.lexer import Lexer
+from mako import runtime, util, exceptions, codegen
+import imp, os, re, shutil, stat, sys, tempfile, time, types, weakref
+
+
+class Template(object):
+ """Represents a compiled template.
+
+ :class:`.Template` includes a reference to the original
+ template source (via the ``.source`` attribute)
+ as well as the source code of the
+ generated Python module (i.e. the ``.code`` attribute),
+ as well as a reference to an actual Python module.
+
+ :class:`.Template` is constructed using either a literal string
+ representing the template text, or a filename representing a filesystem
+ path to a source file.
+
+ :param text: textual template source. This argument is mutually
+ exclusive versus the "filename" parameter.
+
+ :param filename: filename of the source template. This argument is
+ mutually exclusive versus the "text" parameter.
+
+ :param buffer_filters: string list of filters to be applied
+ to the output of %defs which are buffered, cached, or otherwise
+ filtered, after all filters
+ defined with the %def itself have been applied. Allows the
+ creation of default expression filters that let the output
+ of return-valued %defs "opt out" of that filtering via
+ passing special attributes or objects.
+
+ :param bytestring_passthrough: When True, and output_encoding is
+ set to None, and :meth:`.Template.render` is used to render,
+ the StringIO or cStringIO buffer will be used instead of the
+ default "fast" buffer. This allows raw bytestrings in the
+ output stream, such as in expressions, to pass straight
+ through to the buffer. New in 0.4 to provide the same
+ behavior as that of the previous series. This flag is forced
+ to True if disable_unicode is also configured.
+
+ :param cache_dir: Filesystem directory where cache files will be
+ placed. See :ref:`caching_toplevel`.
+
+ :param cache_enabled: Boolean flag which enables caching of this
+ template. See :ref:`caching_toplevel`.
+
+ :param cache_type: Type of Beaker caching to be applied to the
+ template. See :ref:`caching_toplevel`.
+
+ :param cache_url: URL of a memcached server with which to use
+ for caching. See :ref:`caching_toplevel`.
+
+ :param default_filters: List of string filter names that will
+ be applied to all expressions. See :ref:`filtering_default_filters`.
+
+ :param disable_unicode: Disables all awareness of Python Unicode
+ objects. See :ref:`unicode_disabled`.
+
+ :param encoding_errors: Error parameter passed to ``encode()`` when
+ string encoding is performed. See :ref:`usage_unicode`.
+
+ :param error_handler: Python callable which is called whenever
+ compile or runtime exceptions occur. The callable is passed
+ the current context as well as the exception. If the
+ callable returns ``True``, the exception is considered to
+ be handled, else it is re-raised after the function
+ completes. Is used to provide custom error-rendering
+ functions.
+
+ :param format_exceptions: if ``True``, exceptions which occur during
+ the render phase of this template will be caught and
+ formatted into an HTML error page, which then becomes the
+ rendered result of the :meth:`render` call. Otherwise,
+ runtime exceptions are propagated outwards.
+
+ :param imports: String list of Python statements, typically individual
+ "import" lines, which will be placed into the module level
+ preamble of all generated Python modules. See the example
+ in :ref:`filtering_default_filters`.
+
+ :param input_encoding: Encoding of the template's source code. Can
+ be used in lieu of the coding comment. See
+ :ref:`usage_unicode` as well as :ref:`unicode_toplevel` for
+ details on source encoding.
+
+ :param lookup: a :class:`.TemplateLookup` instance that will be used
+ for all file lookups via the ``<%namespace>``,
+ ``<%include>``, and ``<%inherit>`` tags. See
+ :ref:`usage_templatelookup`.
+
+ :param module_directory: Filesystem location where generated
+ Python module files will be placed.
+
+ :param module_filename: Overrides the filename of the generated
+ Python module file. For advanced usage only.
+
+ :param output_encoding: The encoding to use when :meth:`.render`
+ is called.
+ See :ref:`usage_unicode` as well as :ref:`unicode_toplevel`.
+
+ :param preprocessor: Python callable which will be passed
+ the full template source before it is parsed. The return
+ result of the callable will be used as the template source
+ code.
+
+ :param strict_undefined: Replaces the automatic usage of
+ ``UNDEFINED`` for any undeclared variables not located in
+ the :class:`.Context` with an immediate raise of
+ ``NameError``. The advantage is immediate reporting of
+ missing variables which include the name. New in 0.3.6.
+
+ :param uri: string uri or other identifier for this template.
+ If not provided, the uri is generated from the filesystem
+ path, or from the in-memory identity of a non-file-based
+ template. The primary usage of the uri is to provide a key
+ within :class:`.TemplateLookup`, as well as to generate the
+ file path of the generated Python module file, if
+ ``module_directory`` is specified.
+
+ """
+
+ def __init__(self,
+ text=None,
+ filename=None,
+ uri=None,
+ format_exceptions=False,
+ error_handler=None,
+ lookup=None,
+ output_encoding=None,
+ encoding_errors='strict',
+ module_directory=None,
+ cache_type=None,
+ cache_dir=None,
+ cache_url=None,
+ module_filename=None,
+ input_encoding=None,
+ disable_unicode=False,
+ bytestring_passthrough=False,
+ default_filters=None,
+ buffer_filters=(),
+ strict_undefined=False,
+ imports=None,
+ preprocessor=None,
+ cache_enabled=True):
+ if uri:
+ self.module_id = re.sub(r'\W', "_", uri)
+ self.uri = uri
+ elif filename:
+ self.module_id = re.sub(r'\W', "_", filename)
+ drive, path = os.path.splitdrive(filename)
+ path = os.path.normpath(path).replace(os.path.sep, "/")
+ self.uri = path
+ else:
+ self.module_id = "memory:" + hex(id(self))
+ self.uri = self.module_id
+
+ self.input_encoding = input_encoding
+ self.output_encoding = output_encoding
+ self.encoding_errors = encoding_errors
+ self.disable_unicode = disable_unicode
+ self.bytestring_passthrough = bytestring_passthrough or disable_unicode
+ self.strict_undefined = strict_undefined
+
+ if util.py3k and disable_unicode:
+ raise exceptions.UnsupportedError(
+ "Mako for Python 3 does not "
+ "support disabling Unicode")
+ elif output_encoding and disable_unicode:
+ raise exceptions.UnsupportedError(
+ "output_encoding must be set to "
+ "None when disable_unicode is used.")
+ if default_filters is None:
+ if util.py3k or self.disable_unicode:
+ self.default_filters = ['str']
+ else:
+ self.default_filters = ['unicode']
+ else:
+ self.default_filters = default_filters
+ self.buffer_filters = buffer_filters
+
+ self.imports = imports
+ self.preprocessor = preprocessor
+
+ # if plain text, compile code in memory only
+ if text is not None:
+ (code, module) = _compile_text(self, text, filename)
+ self._code = code
+ self._source = text
+ ModuleInfo(module, None, self, filename, code, text)
+ elif filename is not None:
+ # if template filename and a module directory, load
+ # a filesystem-based module file, generating if needed
+ if module_filename is not None:
+ path = module_filename
+ elif module_directory is not None:
+ u = self.uri
+ if u[0] == '/':
+ u = u[1:]
+ path = os.path.abspath(
+ os.path.join(
+ os.path.normpath(module_directory),
+ os.path.normpath(u) + ".py"
+ )
+ )
+ else:
+ path = None
+
+ module = self._compile_from_file(path, filename)
+ else:
+ raise exceptions.RuntimeException(
+ "Template requires text or filename")
+
+ self.module = module
+ self.filename = filename
+ self.callable_ = self.module.render_body
+ self.format_exceptions = format_exceptions
+ self.error_handler = error_handler
+ self.lookup = lookup
+ self.cache_type = cache_type
+ self.cache_dir = cache_dir
+ self.cache_url = cache_url
+ self.cache_enabled = cache_enabled
+
+ def _compile_from_file(self, path, filename):
+ if path is not None:
+ util.verify_directory(os.path.dirname(path))
+ filemtime = os.stat(filename)[stat.ST_MTIME]
+ if not os.path.exists(path) or \
+ os.stat(path)[stat.ST_MTIME] < filemtime:
+ _compile_module_file(
+ self,
+ open(filename, 'rb').read(),
+ filename,
+ path)
+ module = imp.load_source(self.module_id, path, open(path, 'rb'))
+ del sys.modules[self.module_id]
+ if module._magic_number != codegen.MAGIC_NUMBER:
+ _compile_module_file(
+ self,
+ open(filename, 'rb').read(),
+ filename,
+ path)
+ module = imp.load_source(self.module_id, path, open(path, 'rb'))
+ del sys.modules[self.module_id]
+ ModuleInfo(module, path, self, filename, None, None)
+ else:
+ # template filename and no module directory, compile code
+ # in memory
+ code, module = _compile_text(
+ self,
+ open(filename, 'rb').read(),
+ filename)
+ self._source = None
+ self._code = code
+ ModuleInfo(module, None, self, filename, code, None)
+ return module
+
+ @property
+ def source(self):
+ """return the template source code for this Template."""
+
+ return _get_module_info_from_callable(self.callable_).source
+
+ @property
+ def code(self):
+ """return the module source code for this Template"""
+
+ return _get_module_info_from_callable(self.callable_).code
+
+ @property
+ def cache(self):
+ return self.module._template_cache
+
+ def render(self, *args, **data):
+ """Render the output of this template as a string.
+
+ if the template specifies an output encoding, the string
+ will be encoded accordingly, else the output is raw (raw
+ output uses cStringIO and can't handle multibyte
+ characters). a Context object is created corresponding
+ to the given data. Arguments that are explictly declared
+ by this template's internal rendering method are also
+ pulled from the given \*args, \**data members.
+
+ """
+ return runtime._render(self, self.callable_, args, data)
+
+ def render_unicode(self, *args, **data):
+ """render the output of this template as a unicode object."""
+
+ return runtime._render(self,
+ self.callable_,
+ args,
+ data,
+ as_unicode=True)
+
+ def render_context(self, context, *args, **kwargs):
+ """Render this Template with the given context.
+
+ the data is written to the context's buffer.
+
+ """
+ if getattr(context, '_with_template', None) is None:
+ context._with_template = self
+ runtime._render_context(self,
+ self.callable_,
+ context,
+ *args,
+ **kwargs)
+
+ def has_def(self, name):
+ return hasattr(self.module, "render_%s" % name)
+
+ def get_def(self, name):
+ """Return a def of this template as a :class:`.DefTemplate`."""
+
+ return DefTemplate(self, getattr(self.module, "render_%s" % name))
+
+ def _get_def_callable(self, name):
+ return getattr(self.module, "render_%s" % name)
+
+ @property
+ def last_modified(self):
+ return self.module._modified_time
+
+class ModuleTemplate(Template):
+ """A Template which is constructed given an existing Python module.
+
+ e.g.::
+
+ t = Template("this is a template")
+ f = file("mymodule.py", "w")
+ f.write(t.code)
+ f.close()
+
+ import mymodule
+
+ t = ModuleTemplate(mymodule)
+ print t.render()
+
+ """
+
+ def __init__(self, module,
+ module_filename=None,
+ template=None,
+ template_filename=None,
+ module_source=None,
+ template_source=None,
+ output_encoding=None,
+ encoding_errors='strict',
+ disable_unicode=False,
+ bytestring_passthrough=False,
+ format_exceptions=False,
+ error_handler=None,
+ lookup=None,
+ cache_type=None,
+ cache_dir=None,
+ cache_url=None,
+ cache_enabled=True
+ ):
+ self.module_id = re.sub(r'\W', "_", module._template_uri)
+ self.uri = module._template_uri
+ self.input_encoding = module._source_encoding
+ self.output_encoding = output_encoding
+ self.encoding_errors = encoding_errors
+ self.disable_unicode = disable_unicode
+ self.bytestring_passthrough = bytestring_passthrough or disable_unicode
+
+ if util.py3k and disable_unicode:
+ raise exceptions.UnsupportedError(
+ "Mako for Python 3 does not "
+ "support disabling Unicode")
+ elif output_encoding and disable_unicode:
+ raise exceptions.UnsupportedError(
+ "output_encoding must be set to "
+ "None when disable_unicode is used.")
+
+ self.module = module
+ self.filename = template_filename
+ ModuleInfo(module,
+ module_filename,
+ self,
+ template_filename,
+ module_source,
+ template_source)
+
+ self.callable_ = self.module.render_body
+ self.format_exceptions = format_exceptions
+ self.error_handler = error_handler
+ self.lookup = lookup
+ self.cache_type = cache_type
+ self.cache_dir = cache_dir
+ self.cache_url = cache_url
+ self.cache_enabled = cache_enabled
+
+class DefTemplate(Template):
+ """a Template which represents a callable def in a parent
+ template."""
+
+ def __init__(self, parent, callable_):
+ self.parent = parent
+ self.callable_ = callable_
+ self.output_encoding = parent.output_encoding
+ self.module = parent.module
+ self.encoding_errors = parent.encoding_errors
+ self.format_exceptions = parent.format_exceptions
+ self.error_handler = parent.error_handler
+ self.lookup = parent.lookup
+ self.bytestring_passthrough = parent.bytestring_passthrough
+
+ def get_def(self, name):
+ return self.parent.get_def(name)
+
+class ModuleInfo(object):
+ """Stores information about a module currently loaded into
+ memory, provides reverse lookups of template source, module
+ source code based on a module's identifier.
+
+ """
+ _modules = weakref.WeakValueDictionary()
+
+ def __init__(self,
+ module,
+ module_filename,
+ template,
+ template_filename,
+ module_source,
+ template_source):
+ self.module = module
+ self.module_filename = module_filename
+ self.template_filename = template_filename
+ self.module_source = module_source
+ self.template_source = template_source
+ self._modules[module.__name__] = template._mmarker = self
+ if module_filename:
+ self._modules[module_filename] = self
+
+ @property
+ def code(self):
+ if self.module_source is not None:
+ return self.module_source
+ else:
+ return open(self.module_filename).read()
+
+ @property
+ def source(self):
+ if self.template_source is not None:
+ if self.module._source_encoding and \
+ not isinstance(self.template_source, unicode):
+ return self.template_source.decode(
+ self.module._source_encoding)
+ else:
+ return self.template_source
+ else:
+ if self.module._source_encoding:
+ return open(self.template_filename, 'rb').read().\
+ decode(self.module._source_encoding)
+ else:
+ return open(self.template_filename).read()
+
+def _compile_text(template, text, filename):
+ identifier = template.module_id
+ lexer = Lexer(text,
+ filename,
+ disable_unicode=template.disable_unicode,
+ input_encoding=template.input_encoding,
+ preprocessor=template.preprocessor)
+ node = lexer.parse()
+
+ source = codegen.compile(node,
+ template.uri,
+ filename,
+ default_filters=template.default_filters,
+ buffer_filters=template.buffer_filters,
+ imports=template.imports,
+ source_encoding=lexer.encoding,
+ generate_magic_comment=template.disable_unicode,
+ disable_unicode=template.disable_unicode,
+ strict_undefined=template.strict_undefined)
+
+ cid = identifier
+ if not util.py3k and isinstance(cid, unicode):
+ cid = cid.encode()
+ module = types.ModuleType(cid)
+ code = compile(source, cid, 'exec')
+ exec code in module.__dict__, module.__dict__
+ return (source, module)
+
+def _compile_module_file(template, text, filename, outputpath):
+ identifier = template.module_id
+ lexer = Lexer(text,
+ filename,
+ disable_unicode=template.disable_unicode,
+ input_encoding=template.input_encoding,
+ preprocessor=template.preprocessor)
+
+ node = lexer.parse()
+ source = codegen.compile(node,
+ template.uri,
+ filename,
+ default_filters=template.default_filters,
+ buffer_filters=template.buffer_filters,
+ imports=template.imports,
+ source_encoding=lexer.encoding,
+ generate_magic_comment=True,
+ disable_unicode=template.disable_unicode,
+ strict_undefined=template.strict_undefined)
+
+ # make tempfiles in the same location as the ultimate
+ # location. this ensures they're on the same filesystem,
+ # avoiding synchronization issues.
+ (dest, name) = tempfile.mkstemp(dir=os.path.dirname(outputpath))
+
+ if isinstance(source, unicode):
+ source = source.encode(lexer.encoding or 'ascii')
+
+ os.write(dest, source)
+ os.close(dest)
+ shutil.move(name, outputpath)
+
+def _get_module_info_from_callable(callable_):
+ return _get_module_info(callable_.func_globals['__name__'])
+
+def _get_module_info(filename):
+ return ModuleInfo._modules[filename]
+
diff --git a/mako/util.py b/mako/util.py
new file mode 100644
index 00000000..5518b4dd
--- /dev/null
+++ b/mako/util.py
@@ -0,0 +1,352 @@
+# mako/util.py
+# Copyright (C) 2006-2011 the Mako authors and contributors
+#
+# This module is part of Mako and is released under
+# the MIT License: http://www.opensource.org/licenses/mit-license.php
+
+import sys
+
+
+py3k = getattr(sys, 'py3kwarning', False) or sys.version_info >= (3, 0)
+py24 = sys.version_info >= (2, 4) and sys.version_info < (2, 5)
+jython = sys.platform.startswith('java')
+win32 = sys.platform.startswith('win')
+
+if py3k:
+ from io import StringIO
+else:
+ try:
+ from cStringIO import StringIO
+ except:
+ from StringIO import StringIO
+
+import codecs, re, weakref, os, time, operator
+import collections
+
+try:
+ import threading
+ import thread
+except ImportError:
+ import dummy_threading as threading
+ import dummy_thread as thread
+
+if win32 or jython:
+ time_func = time.clock
+else:
+ time_func = time.time
+
+def function_named(fn, name):
+ """Return a function with a given __name__.
+
+ Will assign to __name__ and return the original function if possible on
+ the Python implementation, otherwise a new function will be constructed.
+
+ """
+ fn.__name__ = name
+ return fn
+
+try:
+ from functools import partial
+except:
+ def partial(func, *args, **keywords):
+ def newfunc(*fargs, **fkeywords):
+ newkeywords = keywords.copy()
+ newkeywords.update(fkeywords)
+ return func(*(args + fargs), **newkeywords)
+ return newfunc
+
+if py24:
+ def exception_name(exc):
+ try:
+ return exc.__class__.__name__
+ except AttributeError:
+ return exc.__name__
+else:
+ def exception_name(exc):
+ return exc.__class__.__name__
+
+def verify_directory(dir):
+ """create and/or verify a filesystem directory."""
+
+ tries = 0
+
+ while not os.path.exists(dir):
+ try:
+ tries += 1
+ os.makedirs(dir, 0775)
+ except:
+ if tries > 5:
+ raise
+
+def to_list(x, default=None):
+ if x is None:
+ return default
+ if not isinstance(x, (list, tuple)):
+ return [x]
+ else:
+ return x
+
+
+class memoized_property(object):
+ """A read-only @property that is only evaluated once."""
+ def __init__(self, fget, doc=None):
+ self.fget = fget
+ self.__doc__ = doc or fget.__doc__
+ self.__name__ = fget.__name__
+
+ def __get__(self, obj, cls):
+ if obj is None:
+ return self
+ obj.__dict__[self.__name__] = result = self.fget(obj)
+ return result
+
+class SetLikeDict(dict):
+ """a dictionary that has some setlike methods on it"""
+ def union(self, other):
+ """produce a 'union' of this dict and another (at the key level).
+
+ values in the second dict take precedence over that of the first"""
+ x = SetLikeDict(**self)
+ x.update(other)
+ return x
+
+class FastEncodingBuffer(object):
+ """a very rudimentary buffer that is faster than StringIO,
+ but doesn't crash on unicode data like cStringIO."""
+
+ def __init__(self, encoding=None, errors='strict', unicode=False):
+ self.data = collections.deque()
+ self.encoding = encoding
+ if unicode:
+ self.delim = u''
+ else:
+ self.delim = ''
+ self.unicode = unicode
+ self.errors = errors
+ self.write = self.data.append
+
+ def truncate(self):
+ self.data = collections.deque()
+ self.write = self.data.append
+
+ def getvalue(self):
+ if self.encoding:
+ return self.delim.join(self.data).encode(self.encoding, self.errors)
+ else:
+ return self.delim.join(self.data)
+
+class LRUCache(dict):
+ """A dictionary-like object that stores a limited number of items, discarding
+ lesser used items periodically.
+
+ this is a rewrite of LRUCache from Myghty to use a periodic timestamp-based
+ paradigm so that synchronization is not really needed. the size management
+ is inexact.
+ """
+
+ class _Item(object):
+ def __init__(self, key, value):
+ self.key = key
+ self.value = value
+ self.timestamp = time_func()
+ def __repr__(self):
+ return repr(self.value)
+
+ def __init__(self, capacity, threshold=.5):
+ self.capacity = capacity
+ self.threshold = threshold
+
+ def __getitem__(self, key):
+ item = dict.__getitem__(self, key)
+ item.timestamp = time_func()
+ return item.value
+
+ def values(self):
+ return [i.value for i in dict.values(self)]
+
+ def setdefault(self, key, value):
+ if key in self:
+ return self[key]
+ else:
+ self[key] = value
+ return value
+
+ def __setitem__(self, key, value):
+ item = dict.get(self, key)
+ if item is None:
+ item = self._Item(key, value)
+ dict.__setitem__(self, key, item)
+ else:
+ item.value = value
+ self._manage_size()
+
+ def _manage_size(self):
+ while len(self) > self.capacity + self.capacity * self.threshold:
+ bytime = sorted(dict.values(self),
+ key=operator.attrgetter('timestamp'), reverse=True)
+ for item in bytime[self.capacity:]:
+ try:
+ del self[item.key]
+ except KeyError:
+ # if we couldnt find a key, most likely some other thread broke in
+ # on us. loop around and try again
+ break
+
+# Regexp to match python magic encoding line
+_PYTHON_MAGIC_COMMENT_re = re.compile(
+ r'[ \t\f]* \# .* coding[=:][ \t]*([-\w.]+)',
+ re.VERBOSE)
+
+def parse_encoding(fp):
+ """Deduce the encoding of a Python source file (binary mode) from magic comment.
+
+ It does this in the same way as the `Python interpreter`__
+
+ .. __: http://docs.python.org/ref/encodings.html
+
+ The ``fp`` argument should be a seekable file object in binary mode.
+ """
+ pos = fp.tell()
+ fp.seek(0)
+ try:
+ line1 = fp.readline()
+ has_bom = line1.startswith(codecs.BOM_UTF8)
+ if has_bom:
+ line1 = line1[len(codecs.BOM_UTF8):]
+
+ m = _PYTHON_MAGIC_COMMENT_re.match(line1.decode('ascii', 'ignore'))
+ if not m:
+ try:
+ import parser
+ parser.suite(line1.decode('ascii', 'ignore'))
+ except (ImportError, SyntaxError):
+ # Either it's a real syntax error, in which case the source
+ # is not valid python source, or line2 is a continuation of
+ # line1, in which case we don't want to scan line2 for a magic
+ # comment.
+ pass
+ else:
+ line2 = fp.readline()
+ m = _PYTHON_MAGIC_COMMENT_re.match(line2.decode('ascii', 'ignore'))
+
+ if has_bom:
+ if m:
+ raise SyntaxError, \
+ "python refuses to compile code with both a UTF8" \
+ " byte-order-mark and a magic encoding comment"
+ return 'utf_8'
+ elif m:
+ return m.group(1)
+ else:
+ return None
+ finally:
+ fp.seek(pos)
+
+def sorted_dict_repr(d):
+ """repr() a dictionary with the keys in order.
+
+ Used by the lexer unit test to compare parse trees based on strings.
+
+ """
+ keys = d.keys()
+ keys.sort()
+ return "{" + ", ".join(["%r: %r" % (k, d[k]) for k in keys]) + "}"
+
+def restore__ast(_ast):
+ """Attempt to restore the required classes to the _ast module if it
+ appears to be missing them
+ """
+ if hasattr(_ast, 'AST'):
+ return
+ _ast.PyCF_ONLY_AST = 2 << 9
+ m = compile("""\
+def foo(): pass
+class Bar(object): pass
+if False: pass
+baz = 'mako'
+1 + 2 - 3 * 4 / 5
+6 // 7 % 8 << 9 >> 10
+11 & 12 ^ 13 | 14
+15 and 16 or 17
+-baz + (not +18) - ~17
+baz and 'foo' or 'bar'
+(mako is baz == baz) is not baz != mako
+mako > baz < mako >= baz <= mako
+mako in baz not in mako""", '', 'exec', _ast.PyCF_ONLY_AST)
+ _ast.Module = type(m)
+
+ for cls in _ast.Module.__mro__:
+ if cls.__name__ == 'mod':
+ _ast.mod = cls
+ elif cls.__name__ == 'AST':
+ _ast.AST = cls
+
+ _ast.FunctionDef = type(m.body[0])
+ _ast.ClassDef = type(m.body[1])
+ _ast.If = type(m.body[2])
+
+ _ast.Name = type(m.body[3].targets[0])
+ _ast.Store = type(m.body[3].targets[0].ctx)
+ _ast.Str = type(m.body[3].value)
+
+ _ast.Sub = type(m.body[4].value.op)
+ _ast.Add = type(m.body[4].value.left.op)
+ _ast.Div = type(m.body[4].value.right.op)
+ _ast.Mult = type(m.body[4].value.right.left.op)
+
+ _ast.RShift = type(m.body[5].value.op)
+ _ast.LShift = type(m.body[5].value.left.op)
+ _ast.Mod = type(m.body[5].value.left.left.op)
+ _ast.FloorDiv = type(m.body[5].value.left.left.left.op)
+
+ _ast.BitOr = type(m.body[6].value.op)
+ _ast.BitXor = type(m.body[6].value.left.op)
+ _ast.BitAnd = type(m.body[6].value.left.left.op)
+
+ _ast.Or = type(m.body[7].value.op)
+ _ast.And = type(m.body[7].value.values[0].op)
+
+ _ast.Invert = type(m.body[8].value.right.op)
+ _ast.Not = type(m.body[8].value.left.right.op)
+ _ast.UAdd = type(m.body[8].value.left.right.operand.op)
+ _ast.USub = type(m.body[8].value.left.left.op)
+
+ _ast.Or = type(m.body[9].value.op)
+ _ast.And = type(m.body[9].value.values[0].op)
+
+ _ast.IsNot = type(m.body[10].value.ops[0])
+ _ast.NotEq = type(m.body[10].value.ops[1])
+ _ast.Is = type(m.body[10].value.left.ops[0])
+ _ast.Eq = type(m.body[10].value.left.ops[1])
+
+ _ast.Gt = type(m.body[11].value.ops[0])
+ _ast.Lt = type(m.body[11].value.ops[1])
+ _ast.GtE = type(m.body[11].value.ops[2])
+ _ast.LtE = type(m.body[11].value.ops[3])
+
+ _ast.In = type(m.body[12].value.ops[0])
+ _ast.NotIn = type(m.body[12].value.ops[1])
+
+
+try:
+ from inspect import CO_VARKEYWORDS, CO_VARARGS
+ def inspect_func_args(fn):
+ co = fn.func_code
+
+ nargs = co.co_argcount
+ names = co.co_varnames
+ args = list(names[:nargs])
+
+ varargs = None
+ if co.co_flags & CO_VARARGS:
+ varargs = co.co_varnames[nargs]
+ nargs = nargs + 1
+ varkw = None
+ if co.co_flags & CO_VARKEYWORDS:
+ varkw = co.co_varnames[nargs]
+
+ return args, varargs, varkw, fn.func_defaults
+except ImportError:
+ import inspect
+ def inspect_func_args(fn):
+ return inspect.getargspec(fn)
headphones
'
+ else:
+ have = ''
+ if results[i][4]:
+ duration = time.strftime("%M:%S", time.gmtime(int(results[i][4])/1000))
+ else:
+ duration = 'n/a'
+ page.append('''