UserResource

Reference

UserResource

User account management

10 min Advanced

ReferenceAPIAdmin

UserResource

Accessed via client.users, this resource manages user accounts. Most operations require the admin or ops role.

User data is returned as plain dictionaries with keys: username, email, display_name, role, is_active, created_at, updated_at.

1

Setup

Connect with admin credentials

# Cell 1 — Parameters
USERNAME = "_FILL_ME_IN_"  # Set your email before running

# Cell 2 — Connect
from graph_olap import GraphOLAPClient
client = GraphOLAPClient(username=USERNAME)

# Cell 3 — Provision
from notebook_setup import provision
personas, _ = provision(USERNAME)
analyst = personas["analyst"]
admin = personas["admin"]
ops = personas["ops"]
client = analyst

2

Listing Users

Browse existing user accounts

list(is_active=None, limit=50, offset=0) -> list[dict]

List user accounts with optional filters.

Parameter	Type	Default	Description
is_active	bool | None	None	Filter by active status
limit	int	50	Maximum results (1—200)
offset	int	0	Number of results to skip

Returns: List of user dictionaries.

Requires: Admin or Ops role.

users = admin.users.list(limit=5)

print(f"Total users: {len(users)}\n")
for u in users:
    active = "active" if u["is_active"] else "inactive"
    print(f'  {u["username"]:<45} {u["role"]:<10} {active}')

# Filter by active status
active_users = admin.users.list(is_active=True)
print(f"Active users: {len(active_users)}")

3

Getting a User

Retrieve a single user by username

get(username) -> dict

Retrieve a user by username. Admin/Ops can view any user; other roles can only view themselves.

Parameter	Type	Description
username	str	Username to look up

Returns: User data dictionary.

Raises: NotFoundError if the user does not exist.

# Use the analyst client's actual username (namespaced by notebook_setup)
user = admin.users.get(client._config.username)

print(f"username:     {user['username']}")
print(f"email:        {user['email']}")
print(f"role:         {user['role']}")
print(f"display_name: {user['display_name']}")
print(f"is_active:    {user['is_active']}")

4

Creating Users

Provision new user accounts

create(username, email, display_name, role="analyst") -> dict

Create a new user account.

Parameter	Type	Default	Description
username	str	required	Unique username
email	str	required	Email address
display_name	str	required	Display name
role	str	"analyst"	User role (analyst, admin, or ops)

Returns: Created user data.

Requires: Admin or Ops role.

test_username = "ref-testuser"

# Idempotent: create or fetch existing user
from graph_olap.exceptions import ConflictError
try:
    new_user = admin.users.create(
        username=test_username,
        email=f"{test_username}@example.com",
        display_name="Reference Test User",
        role="analyst",
    )
    print("Created user:")
except ConflictError:
    new_user = admin.users.get(test_username)
    print("User already exists:")

print(f"  username:     {new_user['username']}")
print(f"  email:        {new_user['email']}")
print(f"  role:         {new_user['role']}")
print(f"  display_name: {new_user['display_name']}")

5

Updating Users

Modify user metadata

update(username, **kwargs) -> dict

Update mutable user fields.

Parameter	Type	Description
username	str	Username to update
**kwargs		Fields to update: email, display_name, is_active

Returns: Updated user data.

Requires: Admin or Ops role.

updated = admin.users.update(
    test_username,
    display_name="Updated Test User",
    email=f"{test_username}[email protected]",
)

print(f"display_name: {updated['display_name']}")
print(f"email:        {updated['email']}")

6

Role Management

Assign roles to users

assign_role(username, role) -> dict

Change a user’s role. Valid roles are analyst, admin, and ops.

Parameter	Type	Description
username	str	Username to update
role	str	New role (analyst, admin, or ops)

Returns: Updated user data.

Requires: Admin or Ops role.

try:
    promoted = admin.users.assign_role(test_username, role="admin")
    print(f"Role after promotion: {promoted['role']}")

    # Demote back to analyst
    demoted = admin.users.assign_role(test_username, role="analyst")
    print(f"Role after demotion:  {demoted['role']}")
except Exception as e:
    # assign_role may not be supported on all deployments
    print(f"assign_role not available: {e}")

7

Deactivation

Disable user accounts

deactivate(username) -> dict

Deactivate a user account. Deactivated users cannot log in or make API requests.

Parameter	Type	Description
username	str	Username to deactivate

Returns: Deactivated user data.

Requires: Admin or Ops role.

try:
    deactivated = admin.users.deactivate(test_username)
    print(f"User {test_username}: is_active={deactivated['is_active']}")
except Exception as e:
    print(f"deactivate not available: {e}")

8

Bootstrap

First-user provisioning

bootstrap(username, email, display_name) -> dict

Bootstrap the very first user with the ops role. This method only succeeds when no users exist in the database — it is used during initial platform setup.

Parameter	Type	Description
username	str	Username for the first user
email	str	Email address
display_name	str	Display name

Returns: Created user data with ops role.

Note: This endpoint is intentionally not demonstrated because it requires an empty user database. In practice, it is called once during platform initialization.

Key Takeaways

• Access user management via client.users with an admin or ops client
• create() provisions new accounts with a default analyst role
• assign_role() promotes or demotes users between analyst, admin, and ops
• deactivate() disables accounts without deleting them
• bootstrap() is a one-time operation for initial platform setup
• All responses are plain dictionaries (no Pydantic model wrapper)