Python

openemail.members

Bu ad alanındaki her yöntem: imzası, parametreleri, döndürdüğü değer ve bir örnek.

Yöntemler

People who share the workspace, their role and the addresses they may use, and the invitations still waiting.

`members.list()`

List everybody with access to the workspace

members:readSonuçlarda sayfa sayfa ilerler

İmza

def list(    *,    limit: int | None = None,    cursor: str | None = None,    api_key: str | None = None,    timeout: float | None = None,) -> Page[MemberResource]

Returns one page of the workspace's members, the owner first and the rest by email. list_all collects every page into one list and iterate walks them lazily. Each row carries two axes that a client must not merge: role and permissions say what the person may do, and addresses and domains say what they may do it to, each with its own access. A whole domain reaches every address on it, including ones made later. A send needs both axes, so emails:send with nothing granted sends from nothing.

The one exception is addresses:all. When permissions holds it, the person reaches every address on every domain of the workspace, including ones added later, and sends as any of them when permissions also holds emails:send. addresses and domains still list only the grants made to them directly, which they may have kept from before or been given since, or none at all. Read reach from permissions first, and from those two lists only when it lacks addresses:all.

The list is a union of people with a membership row and people who only hold address or domain grants and no membership row. The second group comes back with implied set to True and with role['id'] and createdAt set to None, and their role is inferred from their grants: Member if any grant has access set to member, Viewer otherwise. Until someone calls update for them, widening their addresses silently widens what they may do.

The workspace owner is the FIRST row, with isOwner set to True, so an unshared workspace returns one member rather than an empty page. They hold every permission by definition, and add, update and remove refuse them with member_is_owner. Skip the row whose isOwner is True when counting seats.

Parametreler

limitint: Page size, from 1 to 100. The server defaults to 25.
cursorstr: The nextCursor of the previous page. Leave it out for the first page.
api_keystr: Overrides the client API key for this call only.
timeoutfloat: Seconds this call may take, the response included, before it raises OpenEmailNetworkError with is_timeout. It overrides the client's timeout for this call, and 0 turns the limit off.

Döndürür

Page[MemberResource], a dict with items, hasMore and nextCursor. Each item has userId, email, name, image, isOwner, role, implied, permissions, addresses, domains and createdAt.

Örnek

from openemail import openemail page = openemail.members.list(limit=50) for member in page['items']:    if member['implied']:        print(member['email'], member['role']['name'], len(member['addresses'])) if page['hasMore']:    print('more after', page['nextCursor'])

Notlar

Every other method here takes user_id, the account id in userId, not the email address.
An address granted with access set to viewer blocks sending from it even when the role holds emails:send, unless the role also holds addresses:all. Otherwise the two axes are ANDed, never added.
The cursor is opaque and holds where the last row sat in this order, so a row deleted or edited between pages never breaks the walk: the next page starts at the first row that sorts after it. A cursor this list did not hand out is a 400 invalid_cursor.

Şurada da var

API: GET /members
TypeScript: members.list()
Ruby: members.list
CLI: openemail members list

`members.list_all()`

Collect every member into one list

members:readSonuçlarda sayfa sayfa ilerler

İmza

def list_all(    *,    limit: int | None = None,    cursor: str | None = None,    api_key: str | None = None,    timeout: float | None = None,) -> builtins.list[MemberResource]

Walks every page of list and returns all members in one list, the owner first and the rest by email. One request per page.

Parametreler

limitint: Page size for each request, from 1 to 100. The server defaults to 25.
cursorstr: Starts the walk after this cursor instead of the first page.
api_keystr: Overrides the client API key for every page of this walk.
timeoutfloat: Seconds this call may take, the response included, before it raises OpenEmailNetworkError with is_timeout. It overrides the client's timeout for this call, and 0 turns the limit off.

Döndürür

list[MemberResource] holding every member.

Örnek

from openemail import openemail members = openemail.members.list_all(limit=100)seats = [member for member in members if not member['isOwner']] print(len(seats), 'seats in use')

Notlar

If any page fails, the call raises and the members already fetched are discarded.

Şurada da var

API: GET /members
TypeScript: members.listAll()
Ruby: members.list_all

`members.iterate()`

Stream the members one at a time

members:readSonuçlarda sayfa sayfa ilerler

İmza

def iterate(    *,    limit: int | None = None,    cursor: str | None = None,    api_key: str | None = None,    timeout: float | None = None,) -> Iterator[MemberResource]

Returns a generator that yields members one at a time, the owner first and the rest by email, and requests the next page only once the current one is used up. Nothing is fetched until the loop starts, and breaking out of it stops the requests.

Parametreler

limitint: Page size for each request, from 1 to 100. The server defaults to 25.
cursorstr: Starts the walk after this cursor instead of the first page.
api_keystr: Overrides the client API key for every page of this walk.
timeoutfloat: Seconds this call may take, the response included, before it raises OpenEmailNetworkError with is_timeout. It overrides the client's timeout for this call, and 0 turns the limit off.

Döndürür

Iterator[MemberResource], a generator yielding one member per step.

Örnek

from openemail import openemail for member in openemail.members.iterate():    addresses = [grant['address'] for grant in member['addresses']]    print(member['email'], member['role']['name'], addresses)

Notlar

The generator is lazy, so an abandoned loop costs only the pages you consumed.

Şurada da var

API: GET /members
TypeScript: members.iterate()
Ruby: members.iterate

`members.get()`

Read one member by account id

members:read

İmza

def get(    user_id: str,    *,    api_key: str | None = None,    timeout: float | None = None,) -> MemberResource

Returns a single member with their role, resolved permissions and address grants. The lookup runs over the same union as list, so a legacy grant holder with no membership row is found here too, with implied set to True, and the owner's account id returns their row, with isOwner set to True.

The path takes the account id from list, not an email. An email can change on the account, and a stale one would point at the wrong person.

Parametreler

user_idstrZorunlu: The account id from list, not the email address.
api_keystr: Overrides the client API key for this call only.
timeoutfloat: Seconds this call may take, the response included, before it raises OpenEmailNetworkError with is_timeout. It overrides the client's timeout for this call, and 0 turns the limit off.

Döndürür

MemberResource with role (id, name, builtin), implied, the resolved permissions, and addresses holding addressId, address and access.

Örnek

from openemail import openemail member = openemail.members.get('q7Vd3kX9mT2pLw8RzN4bYc6HfJ1sGa5E') print(member['role']['name'], member['implied'])print([(grant['address'], grant['access']) for grant in member['addresses']])

Notlar

A missing member is 404 resource_not_found.
For an implied member, permissions are the Member or Viewer template permissions, not a stored role that roles.get could read.

Şurada da var

API: GET /members/{userId}
TypeScript: members.get()
Ruby: members.get
CLI: openemail members get

`members.add()`

Invite somebody to the workspace with a role

members:write

İmza

def add(    body: MemberAdd,    *,    api_key: str | None = None,    timeout: float | None = None,) -> InvitationResource

Sends an invitation to join the workspace. Whether or not the address already has an OpenEmail account, the answer is an invitation rather than a member: nobody is put into a workspace without accepting, and this method is held to the same rule as the app.

The invitation carries the role, the addresses and the whole domains you name, and grants exactly those the moment it is accepted. Nothing is granted before that. Calling it again for the same address within ten minutes is refused with 409 invitation_too_soon. After that it refreshes the one outstanding invitation rather than sending a second.

Somebody already in the workspace is refused with 422 member_is_owner. Change what an existing member may do with update, grant_address and revoke_address, which only work on people already in.

Role and grants are separate axes. access applies to every id in addressIds and domainIds, and it never widens the role: an access of member under a role without emails:send still cannot send. A role holding addresses:all reaches every address without any ids, and no key or access token can invite with one, because none of them holds that console-only permission.

Parametreler

body['email']strZorunlu: Who to invite. Trimmed and lowercased. It does not need to have an account yet.
body['roleId']strZorunlu: Role id from roles.list. The owner role is refused with 409 role_immutable, and a role holding more than the key itself holds is refused with 403 insufficient_authority. That covers every role with a console-only permission in it, such as addresses:all.
body['addressIds']list[str]: Up to 64 address ids on this workspace the invitation carries, all at access.
body['domainIds']list[str]: Up to 64 domain ids on this workspace the invitation carries, all at access. A whole domain covers every address on it, including ones made later.
body['access']MemberAccess: member reads and sends as the granted addresses, viewer only reads them. Defaults to member.
api_keystr: Overrides the client API key for this call only.
timeoutfloat: Seconds this call may take, the response included, before it raises OpenEmailNetworkError with is_timeout. It overrides the client's timeout for this call, and 0 turns the limit off.

Döndürür

InvitationResource, answered with a 202: the invitation id, what it carries, when it expires, and delivered, which is False when the email did not leave the mail server.

Örnek

from openemail import openemail invitation = openemail.members.add(    {        'email': '[email protected]',        'roleId': 'role_8b1f4c2e9a7d3b60e5f1a2c4',        'domainIds': ['93542ff8-2baa-4f2f-841d-5ceaa074ab0d'],        'access': 'member',    }) print(invitation['id'], invitation['delivered'], invitation['expiresAt'])

Notlar

An unknown roleId is 404 role_not_found with param set to roleId. An address or domain id that is not on this workspace is 422 member_not_found with param set to addressId or domainId.
The workspace owner, and anybody already in the workspace, is refused with 422 member_is_owner.
delivered set to False means the invitation exists but the email did not go out. Send it again with resend_invitation, or from the app, once the ten minute cooldown has passed.
An OAuth access token needs a verification code for this call, and is refused with 403 step_up_required until the app has verified one in the last 60 minutes. is_step_up_required on the error says so. An API key is never asked for a code.
Not retried automatically. Re-posting the same body inside ten minutes is 409 rather than a duplicate.

Şurada da var

API: POST /members
TypeScript: members.add()
Ruby: members.add
CLI: openemail members add

`members.update()`

Change the role a member holds

members:write

İmza

def update(    user_id: str,    patch: MemberPatch,    *,    api_key: str | None = None,    timeout: float | None = None,) -> MemberResource

Moves a member to a different role and changes nothing else, for somebody ALREADY in the workspace. Their address and domain grants are untouched, and grants cannot be patched here at all: grant_address and revoke_address change one grant at a time.

This is also how a legacy grant holder stops being implied. They have address or domain grants and no membership row, this writes one, and from then on implied is False and their permissions come from a role someone chose rather than from what their access implied.

Nobody joins through update. An account that is not in the workspace is 422 member_not_found: invite them with add and they are in once they accept. The owner role cannot be handed out, which is 409 role_immutable, and the workspace owner cannot be given a role, which is 422 member_is_owner.

Parametreler

user_idstrZorunlu: The account id from list, not the email address.
patch['roleId']strZorunlu: Id of the role to move them to.
api_keystr: Overrides the client API key for this call only.
timeoutfloat: Seconds this call may take, the response included, before it raises OpenEmailNetworkError with is_timeout. It overrides the client's timeout for this call, and 0 turns the limit off.

Döndürür

MemberResource with the new role and permissions, and implied set to False.

Örnek

from openemail import openemail member = openemail.members.update(    'q7Vd3kX9mT2pLw8RzN4bYc6HfJ1sGa5E', {'roleId': 'role_2c7e9a1f4b8d3e60c5a7f1b9'}) print(member['role']['name'], member['implied'])

Notlar

The account has to be in the workspace already, by membership row or by a grant. Anybody else is 422 member_not_found. Use add to invite them.
An unknown roleId is 404 role_not_found, and a user id with no OpenEmail account behind it is 404 user_not_found.
A role holding more than the key itself holds is 403 insufficient_authority. No key or access token holds a console-only permission, so a role with addresses:all, billing or workspace:manage in it is handed out only in the app. That includes the seeded Admin, which holds billing.
An OAuth access token needs a verification code for this call, and is refused with 403 step_up_required until the app has verified one in the last 60 minutes. is_step_up_required on the error says so. An API key is never asked for a code.
Retried automatically on network failure, since it names the role it wants and a replay lands on the same row.

Şurada da var

API: PATCH /members/{userId}
TypeScript: members.update()
Ruby: members.update
CLI: openemail members update

`members.remove()`

Remove a member and every address grant they hold

members:write

İmza

def remove(    user_id: str,    *,    api_key: str | None = None,    timeout: float | None = None,) -> RemovedMemberResource

Takes somebody out of the workspace entirely: the membership row and every address grant they hold on it. Removing only the row would drop them from the list while they kept reading the mail, so both go together.

It does not 404 for somebody who is not a member. The people this most needs to reach are legacy grant holders with no membership row, so there is no existence check, and addressesRevoked reports what actually happened. Zero is the honest answer for a no-op.

Their account, their sent mail and anything they wrote are untouched. Only their access to this workspace ends.

Parametreler

user_idstrZorunlu: The account id from list, not the email address.
api_keystr: Overrides the client API key for this call only.
timeoutfloat: Seconds this call may take, the response included, before it raises OpenEmailNetworkError with is_timeout. It overrides the client's timeout for this call, and 0 turns the limit off.

Döndürür

RemovedMemberResource with object set to member, the userId, deleted set to True and addressesRevoked.

Örnek

from openemail import openemail removed = openemail.members.remove('q7Vd3kX9mT2pLw8RzN4bYc6HfJ1sGa5E') print(removed['deleted'], removed['addressesRevoked'])

Notlar

Idempotent on the server, but the SDK does not retry it automatically, so repeat it yourself after a network failure.
The workspace owner is refused with 422 member_is_owner, because their access never came from a membership.
An OAuth access token needs a verification code for this call, and is refused with 403 step_up_required until the app has verified one in the last 60 minutes. is_step_up_required on the error says so. An API key is never asked for a code.

Şurada da var

API: DELETE /members/{userId}
TypeScript: members.remove()
Ruby: members.remove
CLI: openemail members remove

`members.grant_address()`

Grant a member one address or change their access to it

members:write

İmza

def grant_address(    user_id: str,    body: MemberAddressGrant,    *,    api_key: str | None = None,    timeout: float | None = None,) -> MemberResource

Gives one person one address on this workspace, or changes the access they already have to it. It is an upsert: there is one grant per person and address, so posting again with a different access turns a viewer into a member rather than adding a second grant.

This is the address axis and it cannot widen the role. An access of member lets somebody send as the address only if their role also holds emails:send, and otherwise it lets them read.

Granting an address to an account with no membership row makes them appear in list as an implied member whose role is inferred from their grants, so call update as well if the role should be a decision. The whole member comes back, which lets a client redraw the row without another read.

Parametreler

user_idstrZorunlu: The account id from list, not the email address.
body['addressId']strZorunlu: Id of an address on this workspace.
body['access']MemberAccess: member reads and sends as the address, viewer only reads it. Defaults to member.
api_keystr: Overrides the client API key for this call only.
timeoutfloat: Seconds this call may take, the response included, before it raises OpenEmailNetworkError with is_timeout. It overrides the client's timeout for this call, and 0 turns the limit off.

Döndürür

MemberResource with the grant applied, including the full addresses list.

Örnek

from openemail import openemail member = openemail.members.grant_address(    'q7Vd3kX9mT2pLw8RzN4bYc6HfJ1sGa5E',    {'addressId': '4f0c1b6e-2d7a-4a9e-8c35-91b2e7d4f6a0', 'access': 'viewer'},) print([(grant['address'], grant['access']) for grant in member['addresses']])

Notlar

An address id that is not on this workspace is 422 with code member_not_found and param set to addressId.
The workspace owner is refused with 422 member_is_owner, since they already reach every address. A user id with no OpenEmail account behind it is 404 user_not_found.
Gated on members:write rather than on owning the address, so an admin who owns nothing can still manage grants.
An OAuth access token needs a verification code for this call, and is refused with 403 step_up_required until the app has verified one in the last 60 minutes. is_step_up_required on the error says so. An API key is never asked for a code.
Retried automatically on network failure, since replaying the same grant lands on the same row.

Şurada da var

API: POST /members/{userId}/addresses
TypeScript: members.grantAddress()
Ruby: members.grant_address
CLI: openemail members grant-address

`members.revoke_address()`

Take one address back from a member

members:write

İmza

def revoke_address(    user_id: str,    address_id: str,    *,    api_key: str | None = None,    timeout: float | None = None,) -> MemberResource

Removes one address grant and leaves the person in the workspace with their role and their other addresses. This is the narrow revocation to use when somebody changes team.

An address id that is not on this workspace is refused with 422 member_not_found rather than ignored, so a typo cannot report a revocation that never happened. An address that is on the workspace but was never granted to this person is a silent no-op, and the member comes back unchanged.

The member is returned rather than a tombstone, because the useful answer is what they can still reach.

Parametreler

user_idstrZorunlu: The account id from list, not the email address.
address_idstrZorunlu: Id of an address on this workspace.
api_keystr: Overrides the client API key for this call only.
timeoutfloat: Seconds this call may take, the response included, before it raises OpenEmailNetworkError with is_timeout. It overrides the client's timeout for this call, and 0 turns the limit off.

Döndürür

MemberResource with the remaining addresses.

Örnek

from openemail import openemail member = openemail.members.revoke_address(    'q7Vd3kX9mT2pLw8RzN4bYc6HfJ1sGa5E', '4f0c1b6e-2d7a-4a9e-8c35-91b2e7d4f6a0') print([grant['address'] for grant in member['addresses']])

Notlar

Revoking the last grant of an implied member removes them from the workspace entirely. The call still succeeds and returns the member as they stood, without that address.
Somebody who is not a member of this workspace is a 404.
An OAuth access token needs a verification code for this call, and is refused with 403 step_up_required until the app has verified one in the last 60 minutes. is_step_up_required on the error says so. An API key is never asked for a code.
Not retried automatically by the SDK.

Şurada da var

API: DELETE /members/{userId}/addresses/{addressId}
TypeScript: members.revokeAddress()
Ruby: members.revoke_address
CLI: openemail members revoke-address

`members.grant_domain()`

Grant a member a whole domain or change their access to it

members:write

İmza

def grant_domain(    user_id: str,    body: MemberDomainGrant,    *,    api_key: str | None = None,    timeout: float | None = None,) -> MemberResource

Gives one person every address on one domain of this workspace, including addresses added after the grant, or changes the access they already have to it. It is an upsert: there is one grant per person and domain, so calling it again with a different access turns a viewer into a member rather than adding a second grant.

This is the address axis and it cannot widen the role. An access of member lets somebody send from the domain only if their role also holds emails:send, and otherwise it lets them read.

The person has to be in the workspace already, so invite them with add first. The whole member comes back, with the grant in domains.

Parametreler

user_idstrZorunlu: The account id from list, not the email address.
body['domainId']strZorunlu: Id of a domain on this workspace, as domains.list returns it.
body['access']MemberAccess: member reads and sends from the domain, viewer only reads it. Defaults to member.
api_keystr: Overrides the client API key for this call only.
timeoutfloat: Seconds this call may take, the response included, before it raises OpenEmailNetworkError with is_timeout. It overrides the client's timeout for this call, and 0 turns the limit off.

Döndürür

MemberResource with the grant applied, including the full domains list.

Örnek

from openemail import openemail member = openemail.members.grant_domain(    'q7Vd3kX9mT2pLw8RzN4bYc6HfJ1sGa5E',    {'domainId': '7d2a9c41-5b3e-4f8a-9c06-1e2b3c4d5e6f', 'access': 'viewer'},) print([(grant['domain'], grant['access']) for grant in member['domains']])

Notlar

A domain id that is not on this workspace is 422 with code member_not_found and param set to domainId. Somebody who is not in the workspace yet is refused the same way with param set to userId.
The workspace owner is refused with 422 member_is_owner, since they already reach every domain. A user id with no OpenEmail account behind it is 404 user_not_found.
A workspace whose plan has no team access is refused with 403 plan_required. A key or an access token limited to particular addresses or domains is refused with 422 capability_unsupported, and an access token acting for a member can only give a domain that member reaches, or it is refused with 403 insufficient_authority.
An OAuth access token needs a verification code for this call, and is refused with 403 step_up_required until the app has verified one in the last 60 minutes. is_step_up_required on the error says so. An API key is never asked for a code.
Retried automatically on network failure, since replaying the same grant lands on the same row.

Şurada da var

API: POST /members/{userId}/domains
TypeScript: members.grantDomain()
Ruby: members.grant_domain
CLI: openemail members grant-domain

`members.revoke_domain()`

Take a whole domain back from a member

members:write

İmza

def revoke_domain(    user_id: str,    domain_id: str,    *,    api_key: str | None = None,    timeout: float | None = None,) -> MemberResource

Removes one domain grant and leaves the person in the workspace with their role and their other grants. Addresses on that domain that were granted to them one by one stay granted.

A domain id that is not on this workspace is refused with 422 member_not_found rather than ignored, so a typo cannot report a revocation that never happened. A domain that is on the workspace but was never granted to this person is a silent no-op, and the member comes back unchanged.

The member is returned rather than a tombstone, because the useful answer is what they can still reach.

Parametreler

user_idstrZorunlu: The account id from list, not the email address.
domain_idstrZorunlu: Id of a domain on this workspace.
api_keystr: Overrides the client API key for this call only.
timeoutfloat: Seconds this call may take, the response included, before it raises OpenEmailNetworkError with is_timeout. It overrides the client's timeout for this call, and 0 turns the limit off.

Döndürür

MemberResource with the remaining domains.

Örnek

from openemail import openemail member = openemail.members.revoke_domain(    'q7Vd3kX9mT2pLw8RzN4bYc6HfJ1sGa5E', '7d2a9c41-5b3e-4f8a-9c06-1e2b3c4d5e6f') print([grant['domain'] for grant in member['domains']])

Notlar

Somebody who is not a member of this workspace is a 404.
A key or an access token limited to particular addresses or domains is refused with 422 capability_unsupported.
An OAuth access token needs a verification code for this call, and is refused with 403 step_up_required until the app has verified one in the last 60 minutes. is_step_up_required on the error says so. An API key is never asked for a code.
Not retried automatically by the SDK.

Şurada da var

API: DELETE /members/{userId}/domains/{domainId}
TypeScript: members.revokeDomain()
Ruby: members.revoke_domain
CLI: openemail members revoke-domain

`members.list_invitations()`

List the invitations nobody has accepted yet

members:readSonuçlarda sayfa sayfa ilerler

İmza

def list_invitations(    *,    limit: int | None = None,    cursor: str | None = None,    api_key: str | None = None,    timeout: float | None = None,) -> Page[InvitationResource]

Returns one page of the invitations to this workspace that are still waiting, by email: the role and the addresses and whole domains each one grants once accepted, when it expires, and whether the last email reached them. list_all_invitations collects every page into one list and iterate_invitations walks them lazily.

A waiting invitation grants nothing. It becomes access only at the moment somebody accepts it, which is why it is listed apart from list. An expired one stays on the list with expired set to True until it is sent again or withdrawn.

Parametreler

limitint: Page size, from 1 to 100. The server defaults to 25.
cursorstr: The nextCursor of the previous page. Leave it out for the first page.
api_keystr: Overrides the client API key for this call only.
timeoutfloat: Seconds this call may take, the response included, before it raises OpenEmailNetworkError with is_timeout. It overrides the client's timeout for this call, and 0 turns the limit off.

Döndürür

Page[InvitationResource], a dict with items, hasMore and nextCursor. Each item has id, email, role, addresses, domains, expiresAt, expired, lastSentAt, delivered, deliveryError and createdAt.

Örnek

from openemail import openemail page = openemail.members.list_invitations()expired = [invitation['email'] for invitation in page['items'] if invitation['expired']] print('expired, send again or withdraw:', expired)

Notlar

delivered is None when no send outcome was recorded, and False when the email did not leave the mail server, with the reason in deliveryError.
A key limited to particular addresses or domains lists only the invitations that grant nothing outside them.

Şurada da var

API: GET /members/invitations
TypeScript: members.listInvitations()
Ruby: members.list_invitations
CLI: openemail members list-invitations

`members.list_all_invitations()`

Collect every waiting invitation into one list

members:readSonuçlarda sayfa sayfa ilerler

İmza

def list_all_invitations(    *,    limit: int | None = None,    cursor: str | None = None,    api_key: str | None = None,    timeout: float | None = None,) -> builtins.list[InvitationResource]

Walks every page of list_invitations and returns every waiting invitation in one list, by email. One request per page.

Parametreler

limitint: Page size for each request, from 1 to 100. The server defaults to 25.
cursorstr: Starts the walk after this cursor instead of the first page.
api_keystr: Overrides the client API key for every page of this walk.
timeoutfloat: Seconds this call may take, the response included, before it raises OpenEmailNetworkError with is_timeout. It overrides the client's timeout for this call, and 0 turns the limit off.

Döndürür

list[InvitationResource] holding every waiting invitation.

Örnek

from openemail import openemail invitations = openemail.members.list_all_invitations() for invitation in invitations:    print(invitation['email'], invitation['role']['name'], invitation['expiresAt'])

Notlar

If any page fails, the call raises and the invitations already fetched are discarded.

Şurada da var

API: GET /members/invitations
TypeScript: members.listAllInvitations()
Ruby: members.list_all_invitations

`members.iterate_invitations()`

Stream the waiting invitations one at a time

members:readSonuçlarda sayfa sayfa ilerler

İmza

def iterate_invitations(    *,    limit: int | None = None,    cursor: str | None = None,    api_key: str | None = None,    timeout: float | None = None,) -> Iterator[InvitationResource]

Returns a generator that yields one invitation at a time, by email, and requests the next page only once the current one is used up. Nothing is fetched until the loop starts, and breaking out of it stops the requests.

Parametreler

limitint: Page size for each request, from 1 to 100. The server defaults to 25.
cursorstr: Starts the walk after this cursor instead of the first page.
api_keystr: Overrides the client API key for every page of this walk.
timeoutfloat: Seconds this call may take, the response included, before it raises OpenEmailNetworkError with is_timeout. It overrides the client's timeout for this call, and 0 turns the limit off.

Döndürür

Iterator[InvitationResource], a generator yielding one invitation per step.

Örnek

from openemail import openemail for invitation in openemail.members.iterate_invitations():    if invitation['delivered'] is False:        print(invitation['email'], invitation['deliveryError'])

Notlar

The generator is lazy, so an abandoned loop costs only the pages you consumed.

Şurada da var

API: GET /members/invitations
TypeScript: members.iterateInvitations()
Ruby: members.iterate_invitations

`members.revoke_invitation()`

Withdraw an invitation

members:write

İmza

def revoke_invitation(    invitation_id: str,    *,    api_key: str | None = None,    timeout: float | None = None,) -> RevokedInvitationResource

Withdraws an invitation nobody has accepted. Its link stops working at once and nothing it would have granted is granted. It is Withdraw on the members screen. Inviting the same address later with add sends a new one.

Parametreler

invitation_idstrZorunlu: The invitation id from list_invitations.
api_keystr: Overrides the client API key for this call only.
timeoutfloat: Seconds this call may take, the response included, before it raises OpenEmailNetworkError with is_timeout. It overrides the client's timeout for this call, and 0 turns the limit off.

Döndürür

RevokedInvitationResource with object set to invitation, the id and email, and revoked set to True.

Örnek

from openemail import OpenEmailApiError, openemail try:    revoked = openemail.members.revoke_invitation('winv_6bb640f5b99e47deb758f1f5')except OpenEmailApiError as error:    if error.code != 'invitation_accepted':        raise    print('Already accepted. Remove the member instead.')else:    print('Withdrew the invitation to', revoked['email'])

Notlar

An invitation that was accepted first answers 409 invitation_accepted: remove the member instead. One that is unknown or already withdrawn answers 404.
A key limited to particular addresses or domains can withdraw only an invitation that grants nothing outside them.

Şurada da var

API: DELETE /members/invitations/{invitationId}
TypeScript: members.revokeInvitation()
Ruby: members.revoke_invitation
CLI: openemail members revoke-invitation

`members.resend_invitation()`

Send an invitation again

members:write

İmza

def resend_invitation(    invitation_id: str,    *,    api_key: str | None = None,    timeout: float | None = None,) -> InvitationResource

Sends a waiting invitation again: a new link, fourteen more days, and the old link retired, so only the newest email works. It is Send again on the members screen, and it renews an expired invitation too.

Parametreler

invitation_idstrZorunlu: The invitation id from list_invitations.
api_keystr: Overrides the client API key for this call only.
timeoutfloat: Seconds this call may take, the response included, before it raises OpenEmailNetworkError with is_timeout. It overrides the client's timeout for this call, and 0 turns the limit off.

Döndürür

InvitationResource with the new expiresAt and lastSentAt, and delivered for this send.

Örnek

from openemail import openemail invitation = openemail.members.resend_invitation('winv_6bb640f5b99e47deb758f1f5') print(invitation['expiresAt'], invitation['delivered'])

Notlar

The same address cannot be sent to twice within ten minutes: that is 409 invitation_too_soon. The daily limit on invitations is 409 invitation_limit_reached.
The invitation's role cannot hold more than the key does, the rule add applies too: a role with a permission the key or access token lacks, any console-only one such as addresses:all included, is 403 insufficient_authority. An access token acting for a member is also refused with it when the invitation carries addresses or domains that member does not reach.
The SDK does not retry it, because each call sends an email.

Şurada da var

API: POST /members/invitations/{invitationId}/resend
TypeScript: members.resendInvitation()
Ruby: members.resend_invitation
CLI: openemail members resend-invitation