#5138

Committed 04 Jul 2024 04:58PM CUT coverage: 21.835% (-0.02%) from 21.859%

Build # #5138

Build Type

push

coveralls-python

Committed by

benjaminmah

Commit Message

Added check if the dependencies have been landed

Run Details

716 of 3604 branches covered (19.87%)

0 of 8 new or added lines in 1 file covered. (0.0%)

1 existing line in 1 file now uncovered.

1932 of 8848 relevant lines covered (21.84%)

0.22 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/bugbot/rules/not_landed.py

# This Source Code Form is subject to the terms of the Mozilla Public
# License, v. 2.0. If a copy of the MPL was not distributed with this file,
# You can obtain one at http://mozilla.org/MPL/2.0/.

import base64
import random
import re

from libmozdata import utils as lmdutils
from libmozdata.bugzilla import Bugzilla, BugzillaUser
from libmozdata.phabricator import (
    PhabricatorAPI,
    PhabricatorBzNotFoundException,
    PhabricatorRevisionNotFoundException,
)

from bugbot import utils
from bugbot.bzcleaner import BzCleaner

PHAB_URL_PAT = re.compile(r"https://phabricator\.services\.mozilla\.com/D([0-9]+)")


class NotLanded(BzCleaner):
    def __init__(self):
        super(NotLanded, self).__init__()
        self.nweeks = utils.get_config(self.name(), "number_of_weeks", 2)
        self.nyears = utils.get_config(self.name(), "number_of_years", 2)
        self.phab = PhabricatorAPI(utils.get_login_info()["phab_api_key"])
        self.extra_ni = {}

    def description(self):
        return "Open bugs with no activity for {} weeks and a r+ patch which hasn't landed".format(
            self.nweeks
        )

    def has_assignee(self):
        return True

    def get_extra_for_template(self):
        return {"nweeks": self.nweeks}

    def get_extra_for_needinfo_template(self):
        self.extra_ni.update(self.get_extra_for_template())
        return self.extra_ni

    def columns(self):
        return ["id", "summary", "assignee"]

    def handle_bug(self, bug, data):
        if self.has_bot_set_ni(bug):
            return None

        bugid = str(bug["id"])
        assignee = bug.get("assigned_to", "")
        if utils.is_no_assignee(assignee):
            assignee = ""
            nickname = ""
        else:
            nickname = bug["assigned_to_detail"]["nick"]

        data[bugid] = {
            "assigned_to": assignee,
            "nickname": nickname,
            "deps": set(bug["depends_on"]),
        }

        return bug

    def filter_bugs(self, bugs):
        # We must remove bugs which have open dependencies (except meta bugs)
        # because devs may wait for those bugs to be fixed before their patch
        # can land.

        all_deps = set(dep for info in bugs.values() for dep in info["deps"])

        def bug_handler(bug, data):
            if (
                bug["status"] in {"RESOLVED", "VERIFIED", "CLOSED"}
                or "meta" in bug["keywords"]
            ):
                data.add(bug["id"])

        useless = set()
        Bugzilla(
            bugids=list(all_deps),
            include_fields=["id", "keywords", "status"],
            bughandler=bug_handler,
            bugdata=useless,
        ).get_data().wait()

        for bugid, info in bugs.items():
            # finally deps will contain open bugs which are not meta
            info["deps"] -= useless

        # keep bugs with no deps
        bugs = {bugid: info for bugid, info in bugs.items() if not info["deps"]}

        return bugs

    def check_phab(self, attachment, reviewers_phid):
        """Check if the patch in Phabricator has been r+"""
        if attachment["is_obsolete"] == 1:
            return None

        phab_url = base64.b64decode(attachment["data"]).decode("utf-8")

        # extract the revision
        rev = PHAB_URL_PAT.search(phab_url).group(1)
        try:
            data = self.phab.load_revision(
                rev_id=int(rev), queryKey="all", attachments={"reviewers": 1}
            )
        except PhabricatorRevisionNotFoundException:
            return None

        # this is a timestamp
        last_modified = data["fields"]["dateModified"]
        last_modified = lmdutils.get_date_from_timestamp(last_modified)
        if (self.date - last_modified).days <= self.nweeks * 7:
            # Do not do anything if recent changes in the bug
            return False

        reviewers = data["attachments"]["reviewers"]["reviewers"]

        if not reviewers:
            return False

        for reviewer in reviewers:
            if reviewer["status"] != "accepted":
                return False
            reviewers_phid.add(reviewer["reviewerPHID"])

        value = data["fields"]["status"].get("value", "")
        if value == "changes-planned":
            # even if the patch is r+ and not published, some changes may be required
            # so with the value 'changes-planned', the dev can say it's still a wip
            return False

        if value != "published":
            return True

        return False

    def handle_attachment(self, attachment, res):
        ct = attachment["content_type"]
        c = None
        if ct == "text/x-phabricator-request":
            if "phab" not in res or res["phab"]:
                c = self.check_phab(attachment, res["reviewers_phid"])
                if c is not None:
                    res["phab"] = c

        if c is not None:
            attacher = attachment["creator"]
            if "author" in res:
                if attacher in res["author"]:
                    res["author"][attacher] += 1
                else:
                    res["author"][attacher] = 1
            else:
                res["author"] = {attacher: 1}

            if "count" in res:
                res["count"] += 1
            else:
                res["count"] = 1

    def get_patch_data(self, bugs):
        """Get patch information in bugs"""
        nightly_pat = Bugzilla.get_landing_patterns(channels=["nightly"])[0][0]

        def comment_handler(bug, bugid, data):
            # if a comment contains a backout: don't nag
            for comment in bug["comments"]:
                comment = comment["text"].lower()
                if nightly_pat.match(comment) and (
                    "backed out" in comment or "backout" in comment
                ):
                    data[bugid]["backout"] = True

        def attachment_id_handler(attachments, bugid, data):
            for a in attachments:
                if (
                    a["content_type"] == "text/x-phabricator-request"
                    and a["is_obsolete"] == 0
                ):
                    data.append(a["id"])

        def attachment_handler(attachments, data):
            for attachment in attachments:
                bugid = str(attachment["bug_id"])
                if bugid in data:
                    data[bugid].append(attachment)
                else:
                    data[bugid] = [attachment]

        def has_blocking_dependencies(attachment):
            rev = PHAB_URL_PAT.search(
                base64.b64decode(attachment["data"]).decode("utf-8")
            ).group(1)
            try:
                revision_data = self.phab.load_revision(rev_id=int(rev))
            except PhabricatorRevisionNotFoundException:
                return None

            stack_graph = revision_data["fields"]["stackGraph"]
            current_revision_phid = revision_data["phid"]
            dependencies = stack_graph[current_revision_phid]

            for dep_phid in dependencies:
                dep_revision_data = self.phab.load_revision(rev_phid=dep_phid)
                dep_status = dep_revision_data["fields"]["status"]["value"]
                if dep_status != "published":
                    return True

            return False

        bugids = list(bugs.keys())
        data = {
            bugid: {"backout": False, "author": None, "count": 0, "dependencies": False}
            for bugid in bugids
        }

        # Get the ids of the attachments of interest
        # to avoid to download images, videos, ...
        attachment_ids = []
        Bugzilla(
            bugids=bugids,
            attachmenthandler=attachment_id_handler,
            attachmentdata=attachment_ids,
            attachment_include_fields=["is_obsolete", "content_type", "id"],
        ).get_data().wait()

        # Once we've the ids we can get the data
        attachments_by_bug = {}
        Bugzilla(
            attachmentids=attachment_ids,
            attachmenthandler=attachment_handler,
            attachmentdata=attachments_by_bug,
            attachment_include_fields=[
                "bug_id",
                "data",
                "is_obsolete",
                "content_type",
                "id",
                "creator",
            ],
        ).get_data().wait()

        for bugid, attachments in attachments_by_bug.items():
            res = {"reviewers_phid": set()}
            for attachment in attachments:
                self.handle_attachment(attachment, res)

            if "phab" in res:
                if res["phab"]:
                    data[bugid]["dependencies"] = has_blocking_dependencies(attachment)
                    data[bugid]["reviewers_phid"] = res["reviewers_phid"]
                    data[bugid]["author"] = res["author"]
                    data[bugid]["count"] = res["count"]

        data = {bugid: v for bugid, v in data.items() if v["author"]}

        if not data:
            return data

        Bugzilla(
            bugids=list(data.keys()),
            commenthandler=comment_handler,
            commentdata=data,
            comment_include_fields=["text"],
        ).get_data().wait()

        data = {
            bugid: v
            for bugid, v in data.items()
            if not v["backout"] and not v["dependencies"]
        }

        return data

    def get_bz_userid(self, phids):
        if not phids:
            return {}

        try:
            data = self.phab.load_bz_account(user_phids=list(phids))
            users = {x["phid"]: x["id"] for x in data}
        except PhabricatorBzNotFoundException:
            return {}

        def handler(user, data):
            data[str(user["id"])] = user["name"]

        data = {}
        BugzillaUser(
            user_names=list(users.values()),
            include_fields=["id", "name"],
            user_handler=handler,
            user_data=data,
        ).wait()

        return {phid: data[id] for phid, id in users.items()}

    def get_nicks(self, nicknames):
        def handler(user, data):
            data[user["name"]] = user["nick"]

        users = set(nicknames.values())
        data = {}
        if users:
            BugzillaUser(
                user_names=list(users),
                include_fields=["name", "nick"],
                user_handler=handler,
                user_data=data,
            ).wait()

        for bugid, name in nicknames.items():
            nicknames[bugid] = (name, data[name])

        return nicknames

    def get_bz_params(self, date):
        self.date = lmdutils.get_date_ymd(date)
        fields = ["flags", "depends_on"]
        params = {
            "include_fields": fields,
            "resolution": "---",
            "f1": "attachment.ispatch",
            "n2": 1,
            "f2": "attachments.isobsolete",
            "f3": "attachments.mimetype",
            "o3": "anywordssubstr",
            "v3": "text/x-phabricator-request",
            "f4": "creation_ts",
            "o4": "greaterthan",
            "v4": f"-{self.nyears}y",
            "f5": "days_elapsed",
            "o5": "greaterthaneq",
            "v5": self.nweeks * 7,
            "n6": 1,
            "f6": "longdesc",
            "o6": "casesubstring",
            "v6": "which didn't land and no activity in this bug for",
            "f7": "status_whiteboard",
            "o7": "notsubstring",
            "v7": "[reminder-test ",
        }

        return params

    def get_bugs(self, date="today", bug_ids=[]):
        bugs = super(NotLanded, self).get_bugs(date=date, bug_ids=bug_ids)
        bugs = self.filter_bugs(bugs)
        bugs_patch = self.get_patch_data(bugs)
        res = {}

        reviewers_phid = set()
        nicknames = {}
        for bugid, data in bugs_patch.items():
            reviewers_phid |= data["reviewers_phid"]
            assignee = bugs[bugid]["assigned_to"]
            if not assignee:
                assignee = max(data["author"], key=data["author"].get)
                nicknames[bugid] = assignee

        bz_reviewers = self.get_bz_userid(reviewers_phid)
        all_reviewers = set(bz_reviewers.keys())
        nicknames = self.get_nicks(nicknames)

        for bugid, data in bugs_patch.items():
            res[bugid] = d = bugs[bugid]
            self.extra_ni[bugid] = data["count"]
            assignee = d["assigned_to"]
            nickname = d["nickname"]

            if not assignee:
                assignee, nickname = nicknames[bugid]

            if not assignee:
                continue

            self.add_auto_ni(bugid, {"mail": assignee, "nickname": nickname})

            common = all_reviewers & data["reviewers_phid"]
            if common:
                reviewer = random.choice(list(common))
                self.add_auto_ni(
                    bugid, {"mail": bz_reviewers[reviewer], "nickname": None}
                )

        return res


if __name__ == "__main__":
    NotLanded().run()

1	# This Source Code Form is subject to the terms of the Mozilla Public
2	# License, v. 2.0. If a copy of the MPL was not distributed with this file,
3	# You can obtain one at http://mozilla.org/MPL/2.0/.
4
5	import base64	×
6	import random	×
7	import re	×
8
9	from libmozdata import utils as lmdutils	×
10	from libmozdata.bugzilla import Bugzilla, BugzillaUser	×
11	from libmozdata.phabricator import (	×
12	PhabricatorAPI,
13	PhabricatorBzNotFoundException,
14	PhabricatorRevisionNotFoundException,
15	)
16
17	from bugbot import utils	×
18	from bugbot.bzcleaner import BzCleaner	×
19
20	PHAB_URL_PAT = re.compile(r"https://phabricator\.services\.mozilla\.com/D([0-9]+)")	×
21
22
23	class NotLanded(BzCleaner):	×
24	def __init__(self):	×
25	super(NotLanded, self).__init__()	×
26	self.nweeks = utils.get_config(self.name(), "number_of_weeks", 2)	×
27	self.nyears = utils.get_config(self.name(), "number_of_years", 2)	×
28	self.phab = PhabricatorAPI(utils.get_login_info()["phab_api_key"])	×
29	self.extra_ni = {}	×
30
31	def description(self):	×
32	return "Open bugs with no activity for {} weeks and a r+ patch which hasn't landed".format(	×
33	self.nweeks
34	)
35
36	def has_assignee(self):	×
37	return True	×
38
39	def get_extra_for_template(self):	×
40	return {"nweeks": self.nweeks}	×
41
42	def get_extra_for_needinfo_template(self):	×
43	self.extra_ni.update(self.get_extra_for_template())	×
44	return self.extra_ni	×
45
46	def columns(self):	×
47	return ["id", "summary", "assignee"]	×
48
49	def handle_bug(self, bug, data):	×
50	if self.has_bot_set_ni(bug):	×
51	return None	×
52
53	bugid = str(bug["id"])	×
54	assignee = bug.get("assigned_to", "")	×
55	if utils.is_no_assignee(assignee):	×
56	assignee = ""	×
57	nickname = ""	×
58	else:
59	nickname = bug["assigned_to_detail"]["nick"]	×
60
61	data[bugid] = {	×
62	"assigned_to": assignee,
63	"nickname": nickname,
64	"deps": set(bug["depends_on"]),
65	}
66
67	return bug	×
68
69	def filter_bugs(self, bugs):	×
70	# We must remove bugs which have open dependencies (except meta bugs)
71	# because devs may wait for those bugs to be fixed before their patch
72	# can land.
73
74	all_deps = set(dep for info in bugs.values() for dep in info["deps"])	×
75
76	def bug_handler(bug, data):	×
77	if (	×
78	bug["status"] in {"RESOLVED", "VERIFIED", "CLOSED"}
79	or "meta" in bug["keywords"]
80	):
81	data.add(bug["id"])	×
82
83	useless = set()	×
84	Bugzilla(	×
85	bugids=list(all_deps),
86	include_fields=["id", "keywords", "status"],
87	bughandler=bug_handler,
88	bugdata=useless,
89	).get_data().wait()
90
91	for bugid, info in bugs.items():	×
92	# finally deps will contain open bugs which are not meta
93	info["deps"] -= useless	×
94
95	# keep bugs with no deps
96	bugs = {bugid: info for bugid, info in bugs.items() if not info["deps"]}	×
97
98	return bugs	×
99
100	def check_phab(self, attachment, reviewers_phid):	×
101	"""Check if the patch in Phabricator has been r+"""
102	if attachment["is_obsolete"] == 1:	×
103	return None	×
104
105	phab_url = base64.b64decode(attachment["data"]).decode("utf-8")	×
106
107	# extract the revision
108	rev = PHAB_URL_PAT.search(phab_url).group(1)	×
109	try:	×
110	data = self.phab.load_revision(	×
111	rev_id=int(rev), queryKey="all", attachments={"reviewers": 1}
112	)
113	except PhabricatorRevisionNotFoundException:	×
114	return None	×
115
116	# this is a timestamp
117	last_modified = data["fields"]["dateModified"]	×
118	last_modified = lmdutils.get_date_from_timestamp(last_modified)	×
119	if (self.date - last_modified).days <= self.nweeks * 7:	×
120	# Do not do anything if recent changes in the bug
121	return False	×
122
123	reviewers = data["attachments"]["reviewers"]["reviewers"]	×
124
125	if not reviewers:	×
126	return False	×
127
128	for reviewer in reviewers:	×
129	if reviewer["status"] != "accepted":	×
130	return False	×
131	reviewers_phid.add(reviewer["reviewerPHID"])	×
132
133	value = data["fields"]["status"].get("value", "")	×
134	if value == "changes-planned":	×
135	# even if the patch is r+ and not published, some changes may be required
136	# so with the value 'changes-planned', the dev can say it's still a wip
137	return False	×
138
139	if value != "published":	×
140	return True	×
141
142	return False	×
143
144	def handle_attachment(self, attachment, res):	×
145	ct = attachment["content_type"]	×
146	c = None	×
147	if ct == "text/x-phabricator-request":	×
148	if "phab" not in res or res["phab"]:	×
149	c = self.check_phab(attachment, res["reviewers_phid"])	×
150	if c is not None:	×
151	res["phab"] = c	×
152
153	if c is not None:	×
154	attacher = attachment["creator"]	×
155	if "author" in res:	×
156	if attacher in res["author"]:	×
157	res["author"][attacher] += 1	×
158	else:
159	res["author"][attacher] = 1	×
160	else:
161	res["author"] = {attacher: 1}	×
162
163	if "count" in res:	×
164	res["count"] += 1	×
165	else:
166	res["count"] = 1	×
167
168	def get_patch_data(self, bugs):	×
169	"""Get patch information in bugs"""
170	nightly_pat = Bugzilla.get_landing_patterns(channels=["nightly"])[0][0]	×
171
172	def comment_handler(bug, bugid, data):	×
173	# if a comment contains a backout: don't nag
174	for comment in bug["comments"]:	×
175	comment = comment["text"].lower()	×
176	if nightly_pat.match(comment) and (	×
177	"backed out" in comment or "backout" in comment
178	):
179	data[bugid]["backout"] = True	×
180
181	def attachment_id_handler(attachments, bugid, data):	×
182	for a in attachments:	×
183	if (	×
184	a["content_type"] == "text/x-phabricator-request"
185	and a["is_obsolete"] == 0
186	):
187	data.append(a["id"])	×
188
189	def attachment_handler(attachments, data):	×
190	for attachment in attachments:	×
191	bugid = str(attachment["bug_id"])	×
192	if bugid in data:	×
193	data[bugid].append(attachment)	×
194	else:
195	data[bugid] = [attachment]	×
196
NEW 197	def has_blocking_dependencies(attachment):	×
198	rev = PHAB_URL_PAT.search(	×
199	base64.b64decode(attachment["data"]).decode("utf-8")
200	).group(1)
201	try:	×
202	revision_data = self.phab.load_revision(rev_id=int(rev))	×
203	except PhabricatorRevisionNotFoundException:	×
204	return None	×
205
206	stack_graph = revision_data["fields"]["stackGraph"]	×
207	current_revision_phid = revision_data["phid"]	×
208	dependencies = stack_graph[current_revision_phid]	×
209
NEW 210	for dep_phid in dependencies:	×
NEW 211	dep_revision_data = self.phab.load_revision(rev_phid=dep_phid)	×
NEW 212	dep_status = dep_revision_data["fields"]["status"]["value"]	×
NEW 213	if dep_status != "published":	×
NEW 214	return True	×
215
NEW 216	return False	×
217
218	bugids = list(bugs.keys())	×
219	data = {	×
220	bugid: {"backout": False, "author": None, "count": 0, "dependencies": False}
221	for bugid in bugids
222	}
223
224	# Get the ids of the attachments of interest
225	# to avoid to download images, videos, ...
226	attachment_ids = []	×
227	Bugzilla(	×
228	bugids=bugids,
229	attachmenthandler=attachment_id_handler,
230	attachmentdata=attachment_ids,
231	attachment_include_fields=["is_obsolete", "content_type", "id"],
232	).get_data().wait()
233
234	# Once we've the ids we can get the data
235	attachments_by_bug = {}	×
236	Bugzilla(	×
237	attachmentids=attachment_ids,
238	attachmenthandler=attachment_handler,
239	attachmentdata=attachments_by_bug,
240	attachment_include_fields=[
241	"bug_id",
242	"data",
243	"is_obsolete",
244	"content_type",
245	"id",
246	"creator",
247	],
248	).get_data().wait()
249
250	for bugid, attachments in attachments_by_bug.items():	×
251	res = {"reviewers_phid": set()}	×
252	for attachment in attachments:	×
253	self.handle_attachment(attachment, res)	×
254
255	if "phab" in res:	×
256	if res["phab"]:	×
NEW 257	data[bugid]["dependencies"] = has_blocking_dependencies(attachment)	×
258	data[bugid]["reviewers_phid"] = res["reviewers_phid"]	×
259	data[bugid]["author"] = res["author"]	×
260	data[bugid]["count"] = res["count"]	×
261
262	data = {bugid: v for bugid, v in data.items() if v["author"]}	×
263
264	if not data:	×
265	return data	×
266
267	Bugzilla(	×
268	bugids=list(data.keys()),
269	commenthandler=comment_handler,
270	commentdata=data,
271	comment_include_fields=["text"],
272	).get_data().wait()
273
274	data = {	×
275	bugid: v
276	for bugid, v in data.items()
277	if not v["backout"] and not v["dependencies"]
278	}
279
280	return data	×
281
282	def get_bz_userid(self, phids):	×
283	if not phids:	×
284	return {}	×
285
286	try:	×
287	data = self.phab.load_bz_account(user_phids=list(phids))	×
288	users = {x["phid"]: x["id"] for x in data}	×
289	except PhabricatorBzNotFoundException:	×
290	return {}	×
291
292	def handler(user, data):	×
293	data[str(user["id"])] = user["name"]	×
294
295	data = {}	×
296	BugzillaUser(	×
297	user_names=list(users.values()),
298	include_fields=["id", "name"],
299	user_handler=handler,
300	user_data=data,
301	).wait()
302
303	return {phid: data[id] for phid, id in users.items()}	×
304
305	def get_nicks(self, nicknames):	×
306	def handler(user, data):	×
307	data[user["name"]] = user["nick"]	×
308
309	users = set(nicknames.values())	×
310	data = {}	×
311	if users:	×
312	BugzillaUser(	×
313	user_names=list(users),
314	include_fields=["name", "nick"],
315	user_handler=handler,
316	user_data=data,
317	).wait()
318
319	for bugid, name in nicknames.items():	×
320	nicknames[bugid] = (name, data[name])	×
321
322	return nicknames	×
323
324	def get_bz_params(self, date):	×
325	self.date = lmdutils.get_date_ymd(date)	×
326	fields = ["flags", "depends_on"]	×
327	params = {	×
328	"include_fields": fields,
329	"resolution": "---",
330	"f1": "attachment.ispatch",
331	"n2": 1,
332	"f2": "attachments.isobsolete",
333	"f3": "attachments.mimetype",
334	"o3": "anywordssubstr",
335	"v3": "text/x-phabricator-request",
336	"f4": "creation_ts",
337	"o4": "greaterthan",
338	"v4": f"-{self.nyears}y",
339	"f5": "days_elapsed",
340	"o5": "greaterthaneq",
341	"v5": self.nweeks * 7,
342	"n6": 1,
343	"f6": "longdesc",
344	"o6": "casesubstring",
345	"v6": "which didn't land and no activity in this bug for",
346	"f7": "status_whiteboard",
347	"o7": "notsubstring",
348	"v7": "[reminder-test ",
349	}
350
351	return params	×
352
353	def get_bugs(self, date="today", bug_ids=[]):	×
354	bugs = super(NotLanded, self).get_bugs(date=date, bug_ids=bug_ids)	×
355	bugs = self.filter_bugs(bugs)	×
356	bugs_patch = self.get_patch_data(bugs)	×
357	res = {}	×
358
359	reviewers_phid = set()	×
360	nicknames = {}	×
361	for bugid, data in bugs_patch.items():	×
362	reviewers_phid \|= data["reviewers_phid"]	×
363	assignee = bugs[bugid]["assigned_to"]	×
364	if not assignee:	×
365	assignee = max(data["author"], key=data["author"].get)	×
366	nicknames[bugid] = assignee	×
367
368	bz_reviewers = self.get_bz_userid(reviewers_phid)	×
369	all_reviewers = set(bz_reviewers.keys())	×
370	nicknames = self.get_nicks(nicknames)	×
371
372	for bugid, data in bugs_patch.items():	×
373	res[bugid] = d = bugs[bugid]	×
374	self.extra_ni[bugid] = data["count"]	×
375	assignee = d["assigned_to"]	×
376	nickname = d["nickname"]	×
377
378	if not assignee:	×
379	assignee, nickname = nicknames[bugid]	×
380
381	if not assignee:	×
382	continue	×
383
384	self.add_auto_ni(bugid, {"mail": assignee, "nickname": nickname})	×
385
386	common = all_reviewers & data["reviewers_phid"]	×
387	if common:	×
388	reviewer = random.choice(list(common))	×
389	self.add_auto_ni(	×
390	bugid, {"mail": bz_reviewers[reviewer], "nickname": None}
391	)
392
393	return res	×
394
395
396	if __name__ == "__main__":	×
397	NotLanded().run()	×

mozilla / relman-auto-nag / #5138

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous