Introduction to Profiles
Jump to QuickStart script for getting all profiles
Technical Reference for Profiles
Profiles in OpenReview represent the identity of users on the platform—such as authors, reviewers, and area chairs. Each profile serves as a record user's publications, affiliations, and roles within the OpenReview system.
What’s in a Profile?
A profile typically includes:
Profile ID: This is the unique identifier in the system, in the format
~First_Last1
This is also sometimes referred to as a "tilde id". While each tilde ID points to a single profile, a profile may have multiple tilde IDs associated with it as a result of adding an alternate name or merging profiles.Name(s): Full name and any alternate names (e.g., name changes, nicknames).
Email(s): Verified email addresses associated with the user. Only the email domains are publicly displayed- even PCs will not see the full emails for users submitting to their venue. Note, if you need to get the full author emails, refer to the instructions here.
Affiliations: Work history or institutional associations.
Publications: Papers the user has authored or co-authored.
Getting a Profile or Profiles
You can get one or more profiles using the Python API using the function openreview.tools.get_profiles()
. This function takes a list of profiles or emails, and for each item in the list, returns one of the following: It is possible to query a profile either using the profile's tilde id, or using any confirmed email to the profile
openreview.tools.get_profiles(client_v2, <LIST_OF_PROFILE_IDS_OR_EMAIL>)
To get multiple profiles, you would use the function openreview.tools.get_profiles()
. This function takes a list of profiles or emails, and for each item in the list, returns a dictionary with the following:
profile_id_list = []
profiles = openreview.tools.get_profiles(client_v2,profile_id_list,as_dict=True)
Other arguments that can be used to get additional informations along with the profiles are:
with_publications
with_relations
with_preferred_emails
Structure of Profiles
Profiles are an OpenReview object that contains properties. The main three properties that you can expect to interact with are: id
, state
, and content
. For more details about each of these fields, see here. Several of the fields of content
include lists or lists of dictionaries, which means that it is necessary to understand the structure of the profile in order to get the profile information.in order to access this data, it is Because you need to flatten the dictionary to create the fields, then extract the content, similarly to how the submission content was extracted. The original profile information looks something like this:
{'active': True,
'state': 'Active'
'content': {'emails': ['[email protected]'],
'emailsConfirmed': ['[email protected]'],
'history': [{'end': None,
'institution': {'country': 'US',
'domain': 'university.edu'},
'position': 'PhD Student',
'start': 2017}],
'homepage': 'https://test.com',
'names': [{'fullname': 'First Last',
'preferred': True,
'username': '~First_Last2'}],
'preferredEmail': '[email protected]',
'relations': []},
'id': '~First_Last2',
...<other metacontent>...
}
To get a tabular format, it is necessary to flatten the profile. After flattening (sample code below) a profile would look like this:
0
https://test.com
True
First Last
~First_Last2
PhD Student
2017
None
US
university.edu
~First_Last2
There will be multiple columns for some profile fields recording each of the entries, for example: names_0_preferred, names_0_fullname
. Because profiles have different numbers of affiliations in their profile, some of these columns will be null for some profiles.
QuickStart: Getting All Profiles
The code below takes a list of profile IDs or emails, and returns a DataFrame with all of the profile information in it in a tabular format.
client_v2 = #connect to the OpenReview Client (API2) with your credentials
from collections.abc import MutableMapping
list_of_profile_ids = []
profile_list = openreview.tools.get_profiles(client_v2,list_of_profile_ids)
def flatten_dict(d, parent_key='', sep='_'):
"""
Recursively flattens a dictionary, concatenating nested keys.
"""
items = []
for k, v in d.items():
new_key = f"{parent_key}{sep}{k}" if parent_key else k
if isinstance(v, MutableMapping):
items.extend(flatten_dict(v, new_key, sep=sep).items())
elif isinstance(v, list):
for i, elem in enumerate(v):
# Handle lists of dictionaries by adding an index
if isinstance(elem, MutableMapping):
items.extend(flatten_dict(elem, f"{new_key}_{i}", sep=sep).items())
else:
# Just add the element if it's not a dictionary
items.append((f"{new_key}_{i}", elem))
else:
items.append((new_key, v))
return dict(items)
def extract_content(d):
flattened = flatten_dict(d.content)
content = {k: v for k, v in flattened.items()}
content['profile_id'] =d.id
return(content)
#Create a DataFrame with the flattened profile content + profile ID
profile_df = pd.DataFrame([extract_content(note) for note in profile_list)
#extract the columns you want included in the data
relevant_columns = ['profile_id'] + [c for c in profile_df.columns if 'history_0' in c]
profile_df_subset = profile_df[relevant_columns]
Once the DataFrame is created, it is possible to create a CSV with this data, or merge it with other OpenReview data. See here for examples on how to combine profile with submission data.
Last updated
Was this helpful?