'''A container object for a bug report. Requires a Bugzilla instance -

def __init__(self, bugzilla, bug_id=None, dict=None, autorefresh=True):

# pylint: disable=redefined-builtin

# API had pre-existing issue that we can't change ('dict' usage)

self.bugzilla = bugzilla

self._bug_fields = []

self.autorefresh = autorefresh

if bug_id:

if not dict:

dict = {}

dict["id"] = bug_id

if dict:

log.debug("Bug(%s)", sorted(dict.keys()))

self._update_dict(dict)

self.weburl = bugzilla.url.replace('xmlrpc.cgi',

'show_bug.cgi?id=%i' % self.bug_id)

def __str__(self):

'''Return a simple string representation of this bug

if hasattr(sys.version_info, "major") and sys.version_info.major >= 3:

return self.__unicode__()

else:

return self.__unicode__().encode(

locale.getpreferredencoding(), 'replace')

def __unicode__(self):

'''Return a simple unicode string representation of this bug'''

return u"#%-6s %-10s - %s - %s" % (self.bug_id, self.bug_status,

self.assigned_to, self.summary)

def __repr__(self):

return '<Bug #%i on %s at %#x>' % (self.bug_id, self.bugzilla.url,

id(self))

def __getattr__(self, name):

refreshed = False

while True:

if refreshed and name in self.__dict__:

# If name was in __dict__ to begin with, __getattr__ would

# have never been called.

return self.__dict__[name]

# pylint: disable=protected-access

aliases = self.bugzilla._get_bug_aliases()

# pylint: enable=protected-access

for newname, oldname in aliases:

if name == oldname and newname in self.__dict__:

return self.__dict__[newname]

# Doing dir(bugobj) does getattr __members__/__methods__,

# don't refresh for those

if name.startswith("__") and name.endswith("__"):

break

if refreshed or not self.autorefresh:

break

log.info("Bug %i missing attribute '%s' - doing implicit "

"refresh(). This will be slow, if you want to avoid "

"this, properly use query/getbug include_fields, and "

"set bugzilla.bug_autorefresh = False to force failure.",

self.bug_id, name)

# We pass the attribute name to getbug, since for something like

# 'attachments' which downloads lots of data we really want the

# user to opt in.

self.refresh(extra_fields=[name])

refreshed = True

raise AttributeError("Bug object has no attribute '%s'" % name)

def refresh(self, include_fields=None, exclude_fields=None,

extra_fields=None):

'''

# pylint: disable=protected-access

r = self.bugzilla._getbug(self.bug_id,

include_fields=include_fields, exclude_fields=exclude_fields,

extra_fields=self._bug_fields + (extra_fields or []))

# pylint: enable=protected-access

self._update_dict(r)

reload = refresh

def _update_dict(self, newdict):

'''

if self.bugzilla:

self.bugzilla.post_translation({}, newdict)

# pylint: disable=protected-access

aliases = self.bugzilla._get_bug_aliases()

# pylint: enable=protected-access

for newname, oldname in aliases:

if oldname not in newdict:

continue

if newname not in newdict:

newdict[newname] = newdict[oldname]

elif newdict[newname] != newdict[oldname]:

log.debug("Update dict contained differing alias values "

"d[%s]=%s and d[%s]=%s , dropping the value "

"d[%s]", newname, newdict[newname], oldname,

newdict[oldname], oldname)

del(newdict[oldname])

for key in newdict.keys():

if key not in self._bug_fields:

self._bug_fields.append(key)

self.__dict__.update(newdict)

if 'id' not in self.__dict__ and 'bug_id' not in self.__dict__:

raise TypeError("Bug object needs a bug_id")

##################

# pickle helpers #

##################

def __getstate__(self):

ret = {}

for key in self._bug_fields:

ret[key] = self.__dict__[key]

return ret

def __setstate__(self, vals):

self._bug_fields = []

self.bugzilla = None

self._update_dict(vals)

#####################

# Modify bug status #

#####################

def setstatus(self, status, comment=None, private=False,

private_in_it=False, nomail=False):

'''

ignore = private_in_it

ignore = nomail

vals = self.bugzilla.build_update(status=status,

comment=comment,

comment_private=private)

log.debug("setstatus: update=%s", vals)

return self.bugzilla.update_bugs(self.bug_id, vals)

def close(self, resolution, dupeid=None, fixedin=None,

comment=None, isprivate=False,

private_in_it=False, nomail=False):

'''Close this bug.

ignore = private_in_it

ignore = nomail

vals = self.bugzilla.build_update(comment=comment,

comment_private=isprivate,

resolution=resolution,

dupe_of=dupeid,

fixed_in=fixedin,

status="CLOSED")

log.debug("close: update=%s", vals)

return self.bugzilla.update_bugs(self.bug_id, vals)

#####################

# Modify bug emails #

#####################

def setassignee(self, assigned_to=None, reporter=None,

qa_contact=None, comment=None):

'''

if reporter:

raise ValueError("reporter can not be changed")

if not (assigned_to or qa_contact):

raise ValueError("You must set one of assigned_to "

" or qa_contact")

vals = self.bugzilla.build_update(assigned_to=assigned_to,

qa_contact=qa_contact,

comment=comment)

log.debug("setassignee: update=%s", vals)

return self.bugzilla.update_bugs(self.bug_id, vals)

def addcc(self, cclist, comment=None):

'''

vals = self.bugzilla.build_update(comment=comment,

cc_add=cclist)

log.debug("addcc: update=%s", vals)

return self.bugzilla.update_bugs(self.bug_id, vals)

def deletecc(self, cclist, comment=None):

'''

vals = self.bugzilla.build_update(comment=comment,

cc_remove=cclist)

log.debug("deletecc: update=%s", vals)

return self.bugzilla.update_bugs(self.bug_id, vals)

###############

# Add comment #

###############

def addcomment(self, comment, private=False,

timestamp=None, worktime=None, bz_gid=None):

'''

ignore = timestamp

ignore = bz_gid

ignore = worktime

vals = self.bugzilla.build_update(comment=comment,

comment_private=private)

log.debug("addcomment: update=%s", vals)

return self.bugzilla.update_bugs(self.bug_id, vals)

##########################

# Get/set bug whiteboard #

##########################

def _dowhiteboard(self, text, which, action, comment, private):

'''

if which not in ["status", "qa", "devel", "internal"]:

raise ValueError("Unknown whiteboard type '%s'" % which)

if not which.endswith('_whiteboard'):

which = which + '_whiteboard'

if which == "status_whiteboard":

which = "whiteboard"

if action != 'overwrite':

wb = getattr(self, which, '').strip()

tags = wb.split()

sep = " "

for t in tags:

if t.endswith(","):

sep = ", "

if action == 'prepend':

text = text + sep + wb

elif action == 'append':

text = wb + sep + text

else:

raise ValueError("Unknown whiteboard action '%s'" % action)

updateargs = {which: text}

vals = self.bugzilla.build_update(comment=comment,

comment_private=private,

**updateargs)

log.debug("_updatewhiteboard: update=%s", vals)

self.bugzilla.update_bugs(self.bug_id, vals)

def appendwhiteboard(self, text, which='status',

comment=None, private=False):

'''Append the given text (with a space before it) to the given

self._dowhiteboard(text, which, "append", comment, private)

def prependwhiteboard(self, text, which='status',

comment=None, private=False):

'''Prepend the given text (with a space following it) to the given

self._dowhiteboard(text, which, "prepend", comment, private)

def setwhiteboard(self, text, which='status',

comment=None, private=False):

'''Overwrites the contents of the given whiteboard with the given text.

self._dowhiteboard(text, which, "overwrite", comment, private)

def addtag(self, tag, which='status'):

'''Adds the given tag to the given bug.'''

whiteboard = self.getwhiteboard(which)

if whiteboard:

self.appendwhiteboard(tag, which)

else:

self.setwhiteboard(tag, which)

def gettags(self, which='status'):

'''Get a list of tags (basically just whitespace-split the given

return self.getwhiteboard(which).split()

def deltag(self, tag, which='status'):

'''Removes the given tag from the given bug.'''

tags = self.gettags(which)

for t in tags:

if t.strip(",") == tag:

tags.remove(t)

self.setwhiteboard(' '.join(tags), which)

#####################

# Get/Set bug flags #

#####################

def get_flag_type(self, name):

"""

for t in self.flags:

if t['name'] == name:

return t

return None

def get_flags(self, name):

"""

ft = self.get_flag_type(name)

if not ft:

return None

return [ft]

def get_flag_status(self, name):

"""

f = self.get_flags(name)

if not f:

return None

# This method works only for simple flags that have only one

# value set.

assert len(f) <= 1

return f[0]['status']

########################

# Experimental methods #

########################

def get_attachment_ids(self):

# pylint: disable=protected-access

proxy = self.bugzilla._proxy

# pylint: enable=protected-access

if "attachments" in self.__dict__:

attachments = self.attachments

else:

rawret = proxy.Bug.attachments(

{"ids": [self.bug_id], "exclude_fields": ["data"]})

attachments = rawret["bugs"][str(self.bug_id)]

return [a["id"] for a in attachments]

def get_history(self):

'''

return self.bugzilla.bugs_history([self.bug_id])

######################

# Deprecated methods #

######################

def getwhiteboard(self, which='status'):

'''

return getattr(self, "%s_whiteboard" % which)

def updateflags(self, flags):

'''

flaglist = []

for key, value in flags.items():

flaglist.append({"name": key, "status": value})

'''Container object for a bugzilla User.

def __init__(self, bugzilla, **kwargs):

self.bugzilla = bugzilla

self.__userid = kwargs.get('id')

self.__name = kwargs.get('name')

self.__email = kwargs.get('email', self.__name)

self.__can_login = kwargs.get('can_login', False)

self.real_name = kwargs.get('real_name', None)

self.password = None

self.groups = kwargs.get('groups', {})

self.groupnames = []

for g in self.groups:

if "name" in g:

self.groupnames.append(g["name"])

self.groupnames.sort()

########################

# Read-only attributes #

########################

# We make these properties so that the user cannot set them. They are

# unaffected by the update() method so it would be misleading to let them

# be changed.

@property

def userid(self):

return self.__userid

@property

def email(self):

return self.__email

@property

def can_login(self):

return self.__can_login

# name is a key in some methods. Mark it dirty when we change it #

@property

def name(self):

return self.__name

def refresh(self):

"""

newuser = self.bugzilla.getuser(self.email)

self.__dict__.update(newuser.__dict__)

def updateperms(self, action, groups):

'''