def get_recommend_reviewer_invitation(submissionId, number):
reply = {
'forum': submissionId,
'signatures': {
'values-regex': '~.*',
'description': 'How your identity will be displayed with the above content.'
},
'readers': {
'values-copied': [CONFERENCE, '{signatures}'],
'description': 'The users who will be allowed to read the above content.'
},
'content': {
'tag': {
'description': 'Recommendation description',
'order': 1,
'values-url': '/groups?id=' + PC,
'required': True
}
}
}
invitation = openreview.Invitation(id = CONFERENCE + '/-/Paper' + str(number) + '/Recommend/Reviewer',
duedate = 1507180500000,
signatures = [CONFERENCE],
writers = [CONFERENCE],
invitees = [],
noninvitees = [],
readers = ['everyone'],
multiReply = True,
reply = reply)
return invitation
def create_revision_invitation(forum, referent, signature):
params = {
'writers': [config.CONF],
'signatures': [config.CONF],
'readers': ['everyone'],
'invitees': [signature],
'process': os.path.abspath(os.path.join(os.path.dirname(__file__), '../process/reviewRevisionProcess.js')),
'reply': {
'forum': forum,
'referent': referent,
'writers': {
'values': [config.CONF]
},
'signatures': {
'values-regex': signature + '|ICLR.cc/2018/Conference'
},
'readers': {
'values':['everyone']
},
'content': config.official_review_params['reply']['content']
}
}
signature_components = signature.split('/')
paper_num = signature_components[3]
anonreviewer = signature_components[4]
revise_review = openreview.Invitation('ICLR.cc/2018/Conference/-/{0}/{1}/Revise_Review'.format(anonreviewer, paper_num), **params)
return revise_review
def get_submit_review_invitation(submissionId, number):
reply = {
'forum': submissionId,
'replyto': submissionId,
'writers': {
'values-regex':
'~.*|%s/Paper%s/AnonReviewer' % (config.CONF, number)
},
'signatures': {
'values-regex':
'~.*|%s/Paper%s/AnonReviewer' % (config.CONF, number)
},
'readers': {
'values': ['everyone'],
'description':
'The users who will be allowed to read the above content.'
},
'nonreaders': {
'values': []
},
'content': {
'title': {
'order': 1,
'value-regex': '.{1,500}',
'description': 'Brief summary of your review.',
'required': True
},
'review': {
'order': 2,
'value-regex': '[\\S\\s]+',
'description':
'Please provide an evaluation of the quality, clarity, originality and significance of this work, including a list of its pros and cons.',
'required': True
},
'rating': {
'order': 3,
'value-dropdown': ['+3', '+2', '+1', '0', '-1', '-2', '-3'],
'required': True
}
}
}
invitation = openreview.Invitation(
id=config.CONF + '/-/Paper' + str(number) + '/Submit/Review',
duedate=config.DUE_TIMESTAMP,
signatures=[config.CONF],
writers=[config.CONF],
invitees=[
config.PROGRAM_CHAIRS,
"{0}/Paper{1}/Reviewers".format(config.CONF, number)
],
noninvitees=["{0}/Paper{1}/Authors".format(config.CONF, number)],
readers=['everyone'],
process=os.path.abspath(
os.path.join(os.path.dirname(__file__),
'../process/reviewProcess.js')),
reply=reply)
return invitation
def _create_edge_invitation(self, edge_id, extendable_readers=False):
'''
Creates an edge invitation given an edge name
e.g. "Affinity_Score"
'''
readers = {'values': [self.conference.get_id()]}
if extendable_readers:
regex = self.conference.get_id() + '|~.*|.*@.*'
if self.match_group.id == self.conference.get_reviewers_id(
) and self.conference.use_area_chairs:
regex += '|' + self.conference.get_area_chairs_id()
readers = {'values-regex': regex}
invitation = openreview.Invitation(
id=edge_id,
invitees=[self.conference.get_id()],
readers=[self.conference.get_id()],
writers=[self.conference.get_id()],
signatures=[self.conference.get_id()],
reply={
'readers': readers,
'writers': {
'values': [self.conference.get_id()]
},
'signatures': {
'values': [self.conference.get_id()]
},
'content': {
'head': {
'type': 'Note',
'query': {
'invitation':
self.conference.get_blind_submission_id()
}
},
'tail': {
'type': 'Profile',
'query': {
'group': self.match_group.id
}
},
'weight': {
'value-regex': r'[-+]?[0-9]*\.?[0-9]*'
},
'label': {
'value-regex': '.*'
}
}
})
invitation = self.client.post_invitation(invitation)
self.client.delete_edges(invitation.id)
return invitation
def create_revision_invitation(n):
revision_invitation = openreview.Invitation(
config.CONF + '/-/Paper{0}/Add/Revision'.format(n.number),
**config.revision_params)
revision_invitation.invitees = [
config.CONF + '/Paper{0}/Authors'.format(n.number)
]
revision_invitation.reply = config.submission_reply
revision_invitation.reply['referent'] = n.forum
revision_invitation.reply['forum'] = n.forum
return revision_invitation
def set_reviewer_recruiter_invitation(self, conference_id, options={}):
default_reply = {
'forum': None,
'replyto': None,
'readers': {
'values': ['~Super_User1']
},
'signatures': {
'values-regex': '\\(anonymous\\)'
},
'writers': {
'values': []
},
'content': invitations.recruitment
}
reply = self.__build_options(default_reply, options.get('reply', {}))
with open(
os.path.join(os.path.dirname(__file__),
'templates/recruitReviewersProcess.js')) as f:
content = f.read()
content = content.replace(
"var CONFERENCE_ID = '';",
"var CONFERENCE_ID = '" + conference_id + "';")
content = content.replace(
"var REVIEWERS_ACCEPTED_ID = '';",
"var REVIEWERS_ACCEPTED_ID = '" +
options.get('reviewers_accepted_id') + "';")
content = content.replace(
"var REVIEWERS_DECLINED_ID = '';",
"var REVIEWERS_DECLINED_ID = '" +
options.get('reviewers_declined_id') + "';")
content = content.replace(
"var HASH_SEED = '';",
"var HASH_SEED = '" + options.get('hash_seed') + "';")
invitation = openreview.Invitation(
id=conference_id + '/-/Recruit_' +
options.get('reviewers_name', 'Reviewers'),
duedate=tools.datetime_millis(
options.get('due_date', datetime.datetime.now())),
readers=['everyone'],
nonreaders=[],
invitees=['everyone'],
noninvitees=[],
writers=[conference_id],
signatures=[conference_id],
reply=reply,
process_string=content)
return self.client.post_invitation(invitation)
def get_review_comment_invitation(submissionId, number, authorsGroupId, areachairGroupId, reviewerNonReadersGroupId):
allGroups = [COCHAIRS, PC, SPC, authorsGroupId]
reply = {
'forum': submissionId,
'invitation': CONFERENCE + '/-/Paper' + str(number) + '/Submit/Review',
'selfReplyOnly': True,
'signatures': {
'values-regex': '|'.join(allGroups) + '|' + CONFERENCE + '/Paper' + str(number) + '/AnonReviewer[0-9]+' + '|' + areachairGroupId,
'description': 'How your identity will be displayed with the above content.'
},
'writers': {
'values-regex': '~.*'
},
'readers': {
'values': allGroups,
'description': 'The users who will be allowed to read the above content.'
},
'nonreaders': {
'values': [reviewerNonReadersGroupId]
},
'content': {
'title': {
'order': 1,
'value-regex': '.{1,500}',
'description': 'Brief summary of your comment.',
'required': True
},
'comment': {
'order': 2,
'value-regex': '[\\S\\s]{1,5000}',
'description': 'Your comment or reply (5000 characters maximum)',
'required': True
}
}
}
invitation = openreview.Invitation(id = CONFERENCE + '/-/Paper' + str(number) + '/Review/Open/Comment',
signatures = [CONFERENCE],
writers = [CONFERENCE],
invitees = allGroups,
noninvitees = [reviewerNonReadersGroupId],
readers = ['everyone'],
process = '../process/commentProcess.js',
reply = reply)
return invitation
def get_tag_invitation(conference, note, due_date):
return openreview.Invitation(
readers=[
conference.get_reviewers_id(note.number),
conference.get_program_chairs_id()
],
invitees=[conference.get_reviewers_id(note.number)],
id=conference.get_invitation_id(name='Support_Desk_Rejection',
number=note.number),
signatures=[conference.get_id()],
writers=[conference.get_id()],
duedate=openreview.tools.datetime_millis(due_date),
expdate=openreview.tools.datetime_millis(due_date),
multiReply=False,
reply={
'forum': note.forum,
'replyto': note.forum,
"readers": {
"description":
"The users who will be allowed to read the above content.",
"values-copied":
[conference.get_program_chairs_id(), '{signatures}']
},
"signatures": {
"description":
"How your identity will be displayed with the above content.",
"values-regex": "~.*"
},
"writers": {
"values-regex": "~.*"
},
"content": {
"tag": {
"description":
"Should this paper have been desk rejected? (Note, this information will remain private, and is not visible to the authors)",
"order": 1,
"value-dropdown": ["No", "Yes"],
"required": True
}
}
})
def get_acceptance_invitation(submissionId, number):
reply = {
'forum': submissionId,
'replyto': submissionId,
'writers': {
'values': ['~UAI_Admin1', COCHAIRS]
},
'signatures': {
'values-regex': '~UAI_Admin1|' + COCHAIRS
},
'readers': {
'values': ['~UAI_Admin1', COCHAIRS],
'description': 'The users who will be allowed to read the above content.'
},
'content': {
'title': {
'order': 0,
'value': "Paper%s Acceptance Decision" % number
},
'decision': {
'order': 1,
'required': True,
'value-radio': [
'Accept (Oral)',
'Accept (Poster)',
'Reject'
]
}
}
}
invitation = openreview.Invitation(id = CONFERENCE + '/-/Paper' + str(number) + '/Acceptance/Decision',
signatures = [CONFERENCE],
writers = [CONFERENCE],
invitees = [ADMIN],
noninvitees = [],
readers = [CONFERENCE, COCHAIRS],
reply = reply)
return invitation
def make_copyright_invitation(submissionId, number, authors):
reply = {
'forum': submissionId,
'replyto': submissionId,
'writers': {
'values-regex': '~.*'
},
'signatures': {
'values-regex': '~.*'
},
'readers': {
'values': [authors, COCHAIRS, CONFERENCE],
'description': 'The users who will be allowed to read the above content.'
},
'content': {
'title': {
'order': 0,
'value': 'Paper{0} Copyright Form'.format(number),
'required': True
},
'pdf': {
'description': 'Upload a copyright PDF form',
'order': 1,
'value-regex': 'upload',
'required':True
},
}
}
invitation = openreview.Invitation(id = CONFERENCE + '/-/Paper' + str(number) + '/Copyright/Form',
duedate = 1498867199000, #Friday, June 30, 2017 11:59:59 PM GMT
signatures = [CONFERENCE],
writers = [CONFERENCE],
invitees = [authors],
noninvitees = [],
readers = [CONFERENCE, authors, COCHAIRS],
reply = reply)
return invitation
def create_metareview_rating_invitation(nonreaders, sac_group, metareview):
paper_group = nonreaders[0].split('/Conflicts')[0]
invitation = openreview.Invitation(id =f'{paper_group}/-/MetaReview{metareview.number}/Rating',
duedate = None,
readers = [sac_group],
invitees = [sac_group],
writers = ['aclweb.org/ACL/2022/Conference'],
signatures = ['aclweb.org/ACL/2022/Conference'],
multiReply=False,
reply = {
'forum': metareview.forum,
'replyto': metareview.id,
'readers': {
'description': 'This rating is only visible to the program chairs and area chair',
'values': ['aclweb.org/ACL/2022/Conference/Program_Chairs', sac_group]
},
'nonreaders': {
'values': nonreaders
},
'signatures': {
'description': 'How your identity will be displayed with the above content.',
'values': [sac_group]
},
'writers': {
'description': 'Users that may modify this record.',
'values': [sac_group]
},
'content': {
'outstanding_meta_review': {
'description': 'Please indicate if you consider this an outstanding meta review.',
'order': 1,
'required': True,
'value-radio': ['Yes', 'No'],
'default': 'No'
}
}
}
)
client.post_invitation(invitation)
def from_template(invitation_template, paper):
new_params = fill_template(invitation_template, paper)
return openreview.Invitation(
id=new_params['id'],
writers=new_params.get('writers'),
invitees=new_params.get('invitees'),
noninvitees=new_params.get('noninvitees'),
readers=new_params.get('readers'),
nonreaders=new_params.get('nonreaders'),
reply=new_params.get('reply', {}),
replyto=new_params.get('replyto'),
forum=new_params.get('forum'),
invitation=new_params.get('invitation'),
signatures=new_params.get('signatures'),
web=new_params.get('web'),
process=new_params.get('process'),
duedate=new_params.get('duedate'),
cdate=new_params.get('cdate'),
rdate=new_params.get('rdate'),
ddate=new_params.get('ddate'),
multiReply=new_params.get('multiReply'),
taskCompletionCount=new_params.get('taskCompletionCount'))
withdrawn_submission_invitation = client.post_invitation(
openreview.Invitation(
id=conference.get_id() + "/-/Withdrawn_Submission",
readers=['everyone'],
writers=[conference.get_id()],
invitees=[conference.get_id()],
noninvitees=[],
signatures=[conference.get_id()],
reply={
'forum': None,
'replyto': None,
'readers': {
'description':
'The users who will be allowed to read the reply content.',
'values-regex':
conference.get_program_chairs_id() + '|' +
conference.get_id() + '/Paper[0-9]*/Authors'
},
'signatures': {
'description':
'How your identity will be displayed with the above content.',
'values': [conference.get_id()]
},
'writers': {
'description': 'Users that may modify this record.',
'values': [conference.get_id()]
},
'content': {}
},
nonreaders=[]))
'''
import openreview
import config
import csv
client = openreview.Client()
print client.baseurl
# set up the new withdrawal procedure
# re-post the submission invitation (slow)
client.post_invitation(
openreview.Invitation(config.SUBMISSION,
duedate=config.DUE_TIMESTAMP,
**config.submission_params))
# post the withdrawn submissions invitation
client.post_invitation(
openreview.Invitation(config.WITHDRAWN_SUBMISSION,
**config.withdrawn_submission_params))
# find all the improperly withdrawn notes
originals = client.get_notes(invitation=config.SUBMISSION)
blinded = client.get_notes(invitation=config.BLIND_SUBMISSION)
withdrawn_blinded = [n for n in blinded if 'withdrawal' in n.content]
# update the writers field of all original notes to include the conference (so that the conference can modify things)
for n in originals:
n.writers = [config.CONF]
def test_save_bulk(self, client):
builder = openreview.conference.ConferenceBuilder(client)
assert builder, 'builder is None'
builder.set_conference_id('NIPS.cc/2020/Workshop/MLITS')
builder.set_submission_stage(public=True)
conference = builder.get_result()
# Edge invitation
inv1 = openreview.Invitation(
id=conference.id + '/-/affinity',
reply={
'content': {
'head': {
'type': 'Note'
},
'tail': {
'type': 'Profile',
},
'label': {
'value-radio':
['Very High', 'High', 'Neutral', 'Low', 'Very Low']
},
'weight': {
'value-regex': r'[0-9]+\.[0-9]'
}
}
})
inv1 = client.post_invitation(inv1)
# Sample note
note = openreview.Note(
invitation=conference.get_submission_id(),
readers=['everyone'],
writers=[conference.id],
signatures=['~Super_User1'],
content={
'title': 'Paper title',
'abstract': 'This is an abstract',
'authorids': ['*****@*****.**'],
'authors': ['Test User'],
'pdf': '/pdf/22234qweoiuweroi22234qweoiuweroi12345678.pdf'
})
note = client.post_note(note)
# Edges
edges = []
for p in range(1000):
edge = openreview.Edge(head=note.id,
tail='~Super_User1',
label='High',
weight=0.5,
invitation=inv1.id,
readers=['everyone'],
writers=[conference.id],
signatures=['~Super_User1'])
edges.append(edge)
openreview.tools.post_bulk_edges(client, edges)
them = list(openreview.tools.iterget_edges(client, invitation=inv1.id))
assert len(edges) == len(them)
},
'confidence': {
'order':
4,
'value-radio': [
'3: The reviewer is absolutely certain that the evaluation is correct and very familiar with the relevant literature',
'2: The reviewer is fairly confident that the evaluation is correct',
'1: The reviewer\'s evaluation is an educated guess'
],
'required':
True
}
}
}
review_parameters = {
'readers': ['everyone'],
'writers': [conference.get_id()],
'signatures': [conference.get_id()],
# The deadline for the reviews is the April 7th.
'duedate': tools.timestamp_GMT(2019, month=4, day=8, hour=0, minute=0),
'expdate': tools.timestamp_GMT(2019, month=4, day=15, hour=0,
minute=0),
'reply': review_reply,
'invitees': [paperGroup + '/Reviewers']
}
invite = openreview.Invitation(paperinv, **review_parameters)
client.post_invitation(invite)
print(invite.id)
def _create_edge_invitation(edge_id, match_group, edited_by_assigned_ac=False):
'''
Creates an edge invitation given an edge name
e.g. "Affinity_Score"
'''
is_assignment_invitation = edge_id.endswith(
'Assignment') or edge_id.endswith('Aggregate_Score')
paper_number = '{head.number}' if is_assignment_invitation else None
edge_readers = [conference.get_id()]
edge_writers = [conference.get_id()]
edge_signatures = [
conference.get_id() + '$',
conference.get_program_chairs_id()
]
edge_nonreaders = {'values-regex': conference.get_authors_id(number='.*')}
if should_read_by_area_chair:
if conference.use_senior_area_chairs:
edge_readers.append(
conference.get_senior_area_chairs_id(number=paper_number))
## Area Chairs should read the edges of the reviewer invitations.
edge_readers.append(conference.get_area_chairs_id(number=paper_number))
if is_assignment_invitation:
if conference.use_senior_area_chairs:
edge_writers.append(
conference.get_senior_area_chairs_id(number=paper_number))
edge_signatures.append(
conference.get_senior_area_chairs_id(number=paper_number))
edge_writers.append(
conference.get_area_chairs_id(number=paper_number))
edge_signatures.append(
conference.get_anon_area_chair_id(number=paper_number,
anon_id='.*'))
edge_nonreaders = {
'values': [conference.get_authors_id(number=paper_number)]
}
readers = {'values-copied': edge_readers + ['{tail}']}
edge_head_type = 'Note'
edge_head_query = {'invitation': conference.get_blind_submission_id()}
if 'Custom_Max_Papers' in edge_id:
edge_head_type = 'Group'
edge_head_query = {'id': edge_id.split('/-/')[0]}
if is_senior_area_chair:
edge_head_type = 'Profile'
edge_head_query = {'group': conference.get_area_chairs_id()}
invitation = openreview.Invitation(
id=edge_id,
invitees=[conference.get_id(), conference.support_user],
readers=[
conference.get_id(),
conference.get_senior_area_chairs_id(),
conference.get_area_chairs_id()
],
writers=[conference.get_id()],
signatures=[conference.get_id()],
reply={
'readers': readers,
'nonreaders': edge_nonreaders,
'writers': {
'values': edge_writers
},
'signatures': {
'values-regex': '|'.join(edge_signatures),
'default': conference.get_program_chairs_id()
},
'content': {
'head': {
'type': edge_head_type,
'query': edge_head_query
},
'tail': {
'type': 'Profile',
'query': {
'group': match_group.id
}
},
'weight': {
'value-regex': r'[-+]?[0-9]*\.?[0-9]*'
},
'label': {
'value-regex': '.*'
}
}
})
invitation = client.post_invitation(invitation)
client.delete_edges(invitation.id)
return invitation
openreview.Invitation(
**{
'id': '{}/-/NeurIPS_Submission'.format(conference_id),
'invitees': [conference.get_program_chairs_id()],
'readers': ['everyone'],
'writers': [conference.get_id()],
'signatures': [conference.get_id()],
'reply': {
'content': {
'title': {
'value-regex': '.*',
'required': True,
},
'abstract': {
'value-regex': '.*',
'required': True
},
'authors': {
'description': 'Comma separated list of author names.',
'values-regex': '.*',
'required': True
},
'authorids': {
'description':
'Comma separated list of author email addresses, lowercased, in the same order as above. For authors with existing OpenReview accounts, please make sure that the provided email address(es) match those listed in the author\'s profile.',
'values-regex': ".*",
'required': False
},
'venue': {
'value': 'NeurIPS 2019',
'required': True
},
'code_link': {
'description': 'url for source code',
'values-regex': '.*',
'required': False
},
'pdf_link': {
'description': 'url for camera ready submission',
'values-regex': '.*',
'required': False
},
},
'forum': None,
'replyto': None,
'signatures': {
'values': [conference.get_program_chairs_id()]
},
'writers': {
'values':
[conference.get_id(),
conference.get_program_chairs_id()]
},
'readers': {
'values': ['everyone']
}
}
}))
bid_invitation = openreview.Invitation(
**{
'id':
'/'.join([conference.get_id(), '-', 'Bid']),
'expdate':
None, # todo
'duedate':
1549425600000, # Tuesday, February 5, 2019 11:00:00 PM EST
'web':
os.path.abspath('../webfield/bidWebfield.js'), # todo
'signatures': [conference.get_id()],
'readers': [
conference.get_id(),
conference.get_program_chairs_id(),
conference.get_area_chairs_id()
],
'invitees': [
conference.get_program_chairs_id(),
conference.get_area_chairs_id()
],
'writers': [conference.get_id()],
'multiReply':
True,
'taskCompletionCount':
50,
'reply': {
'forum': None,
'replyto': None,
'invitation':
'learningtheory.org/COLT/2019/Conference/-/Blind_Submission',
'readers': {
'values-copied': [conference.get_id(), '{signatures}']
},
'signatures': {
'values-regex': '~.*'
},
'content': {
'tag': {
'value-radio': [
'Very High', 'High', 'Neutral', 'Low', 'Very Low',
'Conflict of Interest', 'No Bid'
],
'required':
True
}
}
}
})
openreview.Invitation(
id='{}/-/Claim'.format(conference_id),
readers=['everyone'],
invitees=['~'],
writers=[conference_id],
signatures=[conference_id],
reply={
'content': {
'title': {
'value': 'Claim',
'order': 0,
'required': True
},
'plan': {
'description':
'Your plan to reproduce results(max 5000 chars).',
'order': 1,
'required': True,
'value-regex': '[\\S\\s]{1,5000}'
},
'institution': {
'description':
'Your institution or organization(max 100 chars).',
'order': 2,
'required': True,
'value-regex': '.{1,100}'
}
},
'invitation': '{}/-/NeurIPS_Submission'.format(conference_id),
'signatures': {
'description':
'Your authorized identity to be associated with the above content.',
'values-regex': '~.*'
},
'readers': {
'description':
'The users who will be allowed to read the above content.',
'values-copied':
[conference_id + '/Program_Chairs', '{signatures}']
},
'writers': {
'values-copied': [conference_id, '{signatures}']
}
},
process='../process/claimProcess.py'))
submission_invitation = client.post_invitation(openreview.Invitation(id='cv-foundation.org/ECCV/2018/Conference/-/Submission',
**{
'duedate': 2515811930000,
'readers': ['everyone'],
'writers': [],
'invitees': ['~'],
'signatures': ['~Super_User1'],
'reply': {
'forum': None,
'replyto': None,
'readers': {
'description': 'The users who will be allowed to read the above content.',
'values': ['cv-foundation.org/ECCV/2018/Conference/Program_Chairs']
},
'signatures': {
'description': 'Your authorized identity to be associated with the above content.',
'values': ['~Super_User1']
},
'writers': {
'values': []
},
'content':{
'title': {
'description': 'Title of paper.',
'order': 1,
'value-regex': '.*',
'required':True
},
'authors': {
'description': 'Comma separated list of author names. Please provide real names; identities will be anonymized.',
'order': 2,
'values-regex': ".*",
'required':True
},
'authorids': {
'description': 'Comma separated list of author email addresses, lowercased, in the same order as above. For authors with existing OpenReview accounts, please make sure that the provided email address(es) match those listed in the author\'s profile. Please provide real emails; identities will be anonymized.',
'order': 3,
'values-regex': ".*",
'required':True
},
'abstract': {
'description': 'Abstract of paper.',
'order': 4,
'value-regex': '[\\S\\s]{1,5000}',
'required':True
},
'subject areas': {
'description': 'List of subject areas.',
'order': 5,
'values-regex': ".*",
'required':False
},
'paperId': {
'description': 'ECCV paper Id',
'order': 6,
'value-regex': ".*",
'required':True
}
}
}
}))
suggested_decision_super = openreview.Invitation(
id="aclweb.org/ACL/2022/Conference/-/Suggested_Decision",
readers=["everyone"],
writers=["aclweb.org/ACL/2022/Conference"],
signatures=["aclweb.org/ACL/2022/Conference"],
reply={
"readers": {
"values-copied": [
"aclweb.org/ACL/2022/Conference",
"aclweb.org/ACL/2022/Conference/Senior_Area_Chairs"
"{signatures}"
]
},
"writers": {
"values-copied":
["aclweb.org/ACL/2022/Conference", "{signatures}"]
},
"signatures": {
"values-regex": "~.*"
},
"content": {
"suggested_decision": {
"order":
1,
"value-radio": [
"1 - definite accept",
"2 - possible accept to main conference",
"3 - possible accept to findings", "4 - reject"
],
"description":
"Please select your suggested decision",
"required":
True
},
"justification": {
"order": 3,
"value-regex": "[\\S\\s]{1,200000}",
"description":
"Provide justification for your suggested decision. Add formatting using Markdown and formulas using LaTeX. For more information see https://openreview.net/faq.",
"required": True,
"markdown": True
},
"ranking": {
"order": 2,
"value-regex": "^(5|\d)(\.\d{1,2})?$",
"description":
"If you selected options 2 or 3, provide a numerical score for the paper. It should be a number between 1 and 5 with up to 2 decimal places.",
"required": False
},
"best_paper": {
"order": 4,
"value-radio": ["Best Paper", "Outstanding Paper"],
"description":
"Do you consider this paper either the best or an outstanding paper?",
"required": False
}
}
},
preprocess=pre_content)
metadata_inv = client.post_invitation(
openreview.Invitation(
**{
'id':
'cv-foundation.org/ECCV/2018/Conference/-/Paper_Metadata',
'readers': [
'cv-foundation.org/ECCV/2018/Conference',
'cv-foundation.org/ECCV/2018/Conference/Program_Chairs'
],
'writers': ['cv-foundation.org/ECCV/2018/Conference'],
'signatures': ['cv-foundation.org/ECCV/2018/Conference'],
'reply': {
'forum': None,
'replyto': None,
'invitation':
'cv-foundation.org/ECCV/2018/Conference/-/Submission',
'readers': {
'values': [
'cv-foundation.org/ECCV/2018/Conference',
'cv-foundation.org/ECCV/2018/Conference/Program_Chairs'
]
},
'writers': {
'values': ['cv-foundation.org/ECCV/2018/Conference']
},
'signatures': {
'values': ['cv-foundation.org/ECCV/2018/Conference']
},
'content': {}
}
}))
},
'conflicts': {
'description': 'Comma separated list of email domains of people who would have a conflict of interest in reviewing this paper, (e.g., cs.umass.edu;google.com, etc.).',
'order': 100,
'values-regex': "[^;,\\n]+(,[^,\\n]+)*",
'required':True
}
}
}
submission_reply=reply.copy()
submission_invitation = openreview.Invitation( 'ICLR.cc/2017/workshop/-/submission',
readers=['everyone'],
writers=['ICLR.cc/2017/workshop'],
invitees=['~'],
signatures=['ICLR.cc/2017/pcs'],
reply=submission_reply,
duedate=1487369700000, #duedate is February 17, 2017, 17:15:00 (5:15pm) Eastern Time
process='../process/submissionProcess_workshop.js')
## Create 'request for availability to review' invitation
reviewer_invitation_reply = {
'content': {
'email': {
'description': 'Email address.',
'order': 1,
'value-regex': '\\S+@\\S+\\.\\S+'
},
'key': {
'description': 'Email key hash',
'order': 2,
os.path.join(os.path.dirname(__file__),
"../../../../../../utils/processToFile.js")),
os.path.abspath(
os.path.join(os.path.dirname(__file__),
"../process/submissionProcess.template")),
os.path.abspath(os.path.join(os.path.dirname(__file__), "../process"))
])
invitations = []
## Create the submission invitation, form, and add it to the list of invitations to post
submission_invitation = openreview.Invitation(
CONFERENCE + '/-/Submission',
readers=['everyone'],
writers=[CONFERENCE],
invitees=['~'],
signatures=[CONFERENCE],
duedate=EIGHT_PG_TIMESTAMP_DUE,
process=os.path.abspath(
os.path.join(os.path.dirname(__file__),
'../process/submissionProcess.js')))
submission_invitation.reply = {
'forum': None,
'replyto': None,
'readers': {
'description':
'The users who will be allowed to read the above content.',
'values': ['everyone']
},
'signatures': {
'description':
password=args.password)
sac_name_dictionary = tracks.sac_name_dictionary
desk_rejected_invitation = client.post_invitation(
openreview.Invitation(
id="aclweb.org/ACL/2022/Conference/-/Desk_Rejected_Submission",
writers=['aclweb.org/ACL/2022/Conference'],
readers=['aclweb.org/ACL/2022/Conference'],
signatures=['aclweb.org/ACL/2022/Conference'],
reply={
"readers": {
"values-regex": ".*"
},
"writers": {
"values": ['aclweb.org/ACL/2022/Conference']
},
"signatures": {
"values": ['aclweb.org/ACL/2022/Conference']
},
"content": {
"authorids": {
"values-regex": ".*"
},
"authors": {
"values": ["Anonymous"]
}
}
}))
# Get all ACL 2022 Conference blind submissions
acl_blind_submissions = list(
openreview.tools.iterget_notes(
recruit_invitation = openreview.Invitation(
id = 'learningtheory.org/COLT/2019/Conference/-/Recruit_Reviewers',
readers = ['everyone'],
writers = ['learningtheory.org/COLT/2019/Conference'],
signatures = ['learningtheory.org/COLT/2019/Conference'],
process = '../process/recruitReviewersProcess.js',
web = '../webfield/recruitResponseWebfield.js',
reply = {
'forum': None,
'replyto': None,
'readers': {
'values': ['~Super_User1']
},
'signatures': {
'values-regex': '\\(anonymous\\)'
},
'writers': {
'values': []
},
'content': {
'title': {
'order': 1,
'value': 'Invitation to review response'
},
'email': {
'description': 'email address',
'order': 2,
'value-regex': '.*@.*',
'required':True
},
'key': {
'description': 'Email key hash',
'order': 3,
'value-regex': '.{0,100}',
'required':True
},
'response': {
'description': 'Invitation response',
'order': 4,
'value-radio': ['Yes', 'No'],
'required':True
},
'invitedBy': {
'description': 'Program Committee who invites the sub reviewer',
'order': 5,
'value-regex': '~.*',
'required':True
}
}
})
group.web = f.read()
group.signatures = [client.signature]
updated_group = client.post_group(group)
# add admin group to the conference members
client.add_members_to_group(groups[config.CONFERENCE_ID], config.CONFERENCE_ID + '/Admin')
groups = {}
groups[config.PROGRAM_CHAIRS] = openreview.Group(config.PROGRAM_CHAIRS, **config.program_chairs_params)
groups[config.AREA_CHAIRS] = openreview.Group(config.AREA_CHAIRS, **config.group_params)
groups[config.REVIEWERS] = openreview.Group(config.REVIEWERS, **config.group_params)
groups[config.CONFERENCE_ID] = client.get_group(config.CONFERENCE_ID)
groups[config.CONFERENCE_ID].signatures = [client.signature]
groups[config.CONFERENCE_ID].add_webfield(config.WEBPATH)
invitations = {}
invitations[config.SUBMISSION] = openreview.Invitation(config.SUBMISSION, duedate=config.SUBMISSION_TIMESTAMP, **config.submission_params)
invitations[config.COMMENT] = openreview.Invitation(config.COMMENT, **config.comment_params)
invitations[config.SUBMISSION].reply = config.submission_reply
invitations[config.COMMENT].reply = config.comment_reply
for g in groups.values():
print "Posting group: ", g.id
client.post_group(g)
for i in invitations.values():
print "Posting invitation: ", i.id
client.post_invitation(i)
openreview.Invitation(
id=
'thecvf.com/ECCV/2020/Conference/Emergency_Reviewers/-/Custom_Max_Papers',
signatures=['thecvf.com/ECCV/2020/Conference'],
readers=[
'thecvf.com/ECCV/2020/Conference',
'thecvf.com/ECCV/2020/Conference/Area_Chairs'
],
writers=['thecvf.com/ECCV/2020/Conference'],
invitees=['thecvf.com/ECCV/2020/Conference'],
reply={
'readers': {
'values-copied': [
'thecvf.com/ECCV/2020/Conference',
'thecvf.com/ECCV/2020/Conference/Area_Chairs', '{tail}'
]
},
'nonreaders': {
'values-regex':
'thecvf.com/ECCV/2020/Conference/Paper.*/Authors'
},
'writers': {
'values': ['thecvf.com/ECCV/2020/Conference']
},
'signatures': {
'values': ['thecvf.com/ECCV/2020/Conference']
},
'content': {
'head': {
'query': {
'id':
'thecvf.com/ECCV/2020/Conference/Emergency_Reviewers'
},
'type': 'Group'
},
'tail': {
'query': {
'invitation':
'thecvf.com/ECCV/2020/Conference/-/Blind_Submission'
},
'type': 'Note'
},
'weight': {
'value-regex': '[-+]?[0-9]*\\.?[0-9]*'
},
'label': {
'value-regex': '.*'
}
}
}))
config.AREA_CHAIRS,
config.PROGRAM_CHAIRS
],
**config.public_group_params)
groups[config.AREA_CHAIRS_PLUS] = openreview.Group(
config.AREA_CHAIRS_PLUS,
members=[config.CONF, config.AREA_CHAIRS, config.PROGRAM_CHAIRS],
**config.public_group_params)
groups[config.CONF] = client.get_group(config.CONF)
groups[config.CONF].signatures = [client.signature]
groups[config.CONF].add_webfield(config.WEBPATH)
invitations = {}
invitations[config.SUBMISSION] = openreview.Invitation(
config.SUBMISSION,
duedate=config.DUE_TIMESTAMP,
**config.submission_params)
invitations[config.BLIND_SUBMISSION] = openreview.Invitation(
config.BLIND_SUBMISSION, **config.blind_submission_params)
invitations[config.WITHDRAWN_SUBMISSION] = openreview.Invitation(
config.WITHDRAWN_SUBMISSION, **config.withdrawn_submission_params)
invitations[config.PUBLIC_COMMENT] = openreview.Invitation(
config.PUBLIC_COMMENT, **config.public_comment_params)
invitations[config.ADD_BID] = openreview.Invitation(config.ADD_BID,
**config.add_bid_params)
invitations[config.METADATA] = openreview.Invitation(config.METADATA,
