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': ['[e-mail]'],
             'emailsConfirmed': ['[e-mail]'],
             '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': '[e-mail]',
             '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:

	preferredEmail	homepage	emails_0	names_0_preferred	names_0_fullname	names_0_username	history_0_position	history_0_start	history_0_end	history_0_institution_country	history_0_institution_domain	emailsConfirmed_0	profile_id
0	[e-mail]	https://test.com	[e-mail]	True	First Last	~First_Last2	PhD Student	2017	None	US	university.edu	[e-mail]	~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.