1. illume
  2. bugzilla_bitbucket


bugzilla_bitbucket / create_issues.py

read in the xml, and create the issues.

issues API:

	    title: The title of the new issue.
	    content: The content of the new issue.
	    component: The component associated with the issue.
	    milestone: The milestone associated with the issue.
	    version: The version associated with the issue.
	    responsible: The username of the person responsible for the issue.
	    status: The status of the issue (new, open, resolved, on hold, invalid, duplicate, or wontfix).
	    kind: The kind of issue (bug, enhancement, or proposal).

How to delete an issue:
	curl X DELETE https://api.bitbucket.org/1.0/repositories/pygame/pygame/issues/3

Add --user username:password afterwards to authenticate, otherwise it does not work.


import os,sys,urllib
import pprint
import glob
import xml.etree.cElementTree as ElementTree

issue_keys = "title content component milestone version responsible status kind".split()
valid_status = "new open resolved hold invalid duplicate wontfix".split()
valid_kind = "bug enhancement proposal".split()

def validate_issue(issue):
	for k in issue_keys:
		if k not in issue:
			raise ValueError("%s not in issue" % k)
	if issue.get('status') not in valid_status:
		raise ValueError(":%s: status is not one of %s" % (issue.get('status'), valid_status))
	if issue.get('kind') not in valid_kind:
		raise ValueError(":%s: kind is not one of %s" % (issue.get('kind'), valid_kind))

def create_issue(issue):

	# create http post data from issue
	issue_data = urllib.urlencode(issue)
	return issue_data

def test_create_issue():
	i = dict(title="just a test issue", content="some content to test", component="pygameissues", milestone="bitbucketmigration", version="1.9.2", responsible="illume", status="new", kind="bug")
	print create_issue(i)

# read bugzilla xml data.
def create_bugzilla_dicts():

    # convert xml to a dict.
    class XmlListConfig(list):
        def __init__(self, aList):
            for element in aList:
                if element:
                    # treat like dict
                    if len(element) == 1 or element[0].tag != element[1].tag:
                    # treat like list
                    elif element[0].tag == element[1].tag:
                elif element.text:
                    text = element.text.strip()
                    if text:
    class XmlDictConfig(dict):
        Example usage:

        >>> tree = ElementTree.parse('your_file.xml')
        >>> root = tree.getroot()
        >>> xmldict = XmlDictConfig(root)

        Or, if you want to use an XML string:

        >>> root = ElementTree.XML(xml_string)
        >>> xmldict = XmlDictConfig(root)

        And then use xmldict for what it is... a dict.
        def __init__(self, parent_element):
            if parent_element.items():
            for element in parent_element:
                if element:
                    # treat like dict - we assume that if the first two tags
                    # in a series are different, then they are all different.
                    if len(element) == 1 or element[0].tag != element[1].tag:
                        aDict = XmlDictConfig(element)
                    # treat like list - we assume that if the first two tags
                    # in a series are the same, then the rest are the same.
                        # here, we put the list in dictionary; the key is the
                        # tag name the list elements all share in common, and
                        # the value is the list itself 
                        aDict = {element[0].tag: XmlListConfig(element)}
                    # if the tag has attributes, add those to the dict
                    if element.items():
                    self.update({element.tag: aDict})
                # this assumes that if you've got an attribute in a tag,
                # you won't be having any text. This may or may not be a 
                # good idea -- time will tell. It works for the way we are
                # currently doing XML configuration files...
                elif element.items():
                    self.update({element.tag: dict(element.items())})
                # finally, if there are no child tags and no attributes, extract
                # the text
                    self.update({element.tag: element.text})

    #convert the bugzilla data to an issue.
    files = glob.glob("xml/*")
    bugs = {}
    for f in files:

        tree = ElementTree.parse(f)
        root = tree.getroot()
        xmldict = XmlDictConfig(root)
        #pprint.pprint( xmldict )
        xmldict['bug']['long_desc'] = []

        root = tree.getroot()
        for x in root.getiterator():
            if x.tag == 'long_desc':

        bugs[xmldict['bug']['bug_id']] = xmldict['bug']

    #pprint.pprint( bugs['3'] )
    return bugs

bugs = create_bugzilla_dicts()