Meeting Operations¶

Operations for managing meetings and meeting-related data.

API Reference¶

MeetingOperations ¶

MeetingOperations(client: Client)

Bases: BaseOperations, MeetingOperationsMixin

Class to handle all operations related to meetings.

Note

This class is already initialized via the client and usable as client.meeting.method

Methods:

list –

List all meetings for a specific user.
attendees –

List all attendees for a specific meeting.
issues –

List all issues for a specific meeting.
todos –

List all todos for a specific meeting.
metrics –

List all metrics for a specific meeting.
details –

Retrieve details of a specific meeting.
create –

Create a new meeting.
delete –

Delete a meeting.
create_many –

Create multiple meetings in a best-effort manner.
get_many –

Retrieve details for multiple meetings in a best-effort manner.

Functions¶

list ¶

list(user_id: int | None = None) -> list[MeetingListItem]

List all meetings for a specific user.

Parameters:

user_id (int | None, default: None ) –

The ID of the user (default is the initialized user ID)

Returns:

list[MeetingListItem] –

A list of MeetingListItem model instances

Example

client.meeting.list()
# Returns: [MeetingListItem(id=123, name="Team Meeting", ...), ...]

attendees ¶

attendees(meeting_id: int) -> list[MeetingAttendee]

List all attendees for a specific meeting.

Parameters:

meeting_id (int) –

The ID of the meeting

Returns:

list[MeetingAttendee] –

A list of MeetingAttendee model instances

Example

client.meeting.attendees(1)
# Returns: [MeetingAttendee(user_id=1, name='John Doe',
#          image_url='...'), ...]

issues ¶

issues(meeting_id: int, include_closed: bool = False) -> list[Issue]

List all issues for a specific meeting.

Parameters:

meeting_id (int) –

The ID of the meeting
include_closed (bool, default: False ) –

Whether to include closed issues (default: False)

Returns:

list[Issue] –

A list of Issue model instances

Example

client.meeting.issues(1)
# Returns: [Issue(id=1, name='Issue Title',
#          created_at='2024-06-10', ...), ...]

todos ¶

todos(meeting_id: int, include_closed: bool = False) -> list[Todo]

List all todos for a specific meeting.

Parameters:

meeting_id (int) –

The ID of the meeting
include_closed (bool, default: False ) –

Whether to include closed todos (default: False)

Returns:

list[Todo] –

A list of Todo model instances

Example

client.meeting.todos(1)
# Returns: [Todo(id=1, name='Todo Title', due_date='2024-06-12', ...), ...]

metrics ¶

metrics(meeting_id: int) -> list[ScorecardMetric]

List all metrics for a specific meeting.

Parameters:

meeting_id (int) –

The ID of the meeting

Returns:

list[ScorecardMetric] –

A list of ScorecardMetric model instances

Example

client.meeting.metrics(1)
# Returns: [ScorecardMetric(id=1, title='Sales', target=100.0,
#           metric_type='>', unit='currency', ...), ...]

details ¶

details(meeting_id: int, include_closed: bool = False) -> MeetingDetails

Retrieve details of a specific meeting.

Parameters:

meeting_id (int) –

The ID of the meeting
include_closed (bool, default: False ) –

Whether to include closed issues and todos (default: False)

Returns:

MeetingDetails –

A MeetingDetails model instance with comprehensive meeting information

Raises:

APIError –

If the meeting with the specified ID is not found

Example

client.meeting.details(1)
# Returns: MeetingDetails(id=1, name='Team Meeting', attendees=[...],
#                        issues=[...], todos=[...], metrics=[...])

create ¶

create(title: str, add_self: bool = True, attendees: list[int] | None = None) -> dict[str, Any]

Create a new meeting.

Parameters:

title (str) –

The title of the new meeting
add_self (bool, default: True ) –

Whether to add the current user as an attendee (default: True)
attendees (list[int] | None, default: None ) –

A list of user IDs to add as attendees

Returns:

dict[str, Any] –

A dictionary containing meeting_id, title and attendees array

Example

client.meeting.create("New Meeting", attendees=[2, 3])
# Returns: {"meeting_id": 1, "title": "New Meeting", "attendees": [2, 3]}

delete ¶

delete(meeting_id: int) -> bool

Delete a meeting.

Parameters:

meeting_id (int) –

The ID of the meeting to delete

Returns:

bool –

True if deletion was successful

Example

client.meeting.delete(1)
# Returns: True

create_many ¶

create_many(meetings: list[dict[str, Any]]) -> BulkCreateResult[dict[str, Any]]

Create multiple meetings in a best-effort manner.

Processes each meeting sequentially to avoid rate limiting. Failed operations are captured and returned alongside successful ones.

Parameters:

meetings (list[dict[str, Any]]) –

List of dictionaries containing meeting data. Each dict should have: - title (required): Title of the meeting - add_self (optional): Whether to add current user as attendee (default: True) - attendees (optional): List of user IDs to add as attendees

Returns:

BulkCreateResult[dict[str, Any]] –

BulkCreateResult containing: - successful: List of dicts with meeting_id, title, and attendees - failed: List of BulkCreateError instances for failed creations

Example

result = client.meeting.create_many([
    {"title": "Weekly Team Meeting", "attendees": [2, 3]},
    {"title": "1:1 Meeting", "add_self": False}
])

print(f"Created {len(result.successful)} meetings")
for error in result.failed:
    print(f"Failed at index {error.index}: {error.error}")

get_many ¶

get_many(meeting_ids: list[int]) -> BulkCreateResult[MeetingDetails]

Retrieve details for multiple meetings in a best-effort manner.

Processes each meeting ID sequentially to avoid rate limiting. Failed operations are captured and returned alongside successful ones.

Parameters:

meeting_ids (list[int]) –

List of meeting IDs to retrieve details for

Returns:

BulkCreateResult[MeetingDetails] –

BulkCreateResult containing: - successful: List of MeetingDetails instances for successfully retrieved meetings - failed: List of BulkCreateError instances for failed retrievals

Example

result = client.meeting.get_many([1, 2, 3])

print(f"Retrieved {len(result.successful)} meetings")
for error in result.failed:
    print(f"Failed at index {error.index}: {error.error}")

Async Version¶

The async version AsyncMeetingOperations provides the same methods as above, but with async/await support:

AsyncMeetingOperations ¶

AsyncMeetingOperations(client: AsyncClient)

Async class to handle all operations related to meetings.

Note

This class is already initialized via the client and usable as client.meeting.method

Performance Benefit

The async details() method fetches attendees, issues, todos, and metrics concurrently, providing better performance than the sync version which fetches them sequentially.

Usage Examples¶

Basic Operations¶

SyncAsync

from bloomy import Client

with Client(api_key="your-api-key") as client:
    # List all meetings for a user
    meetings = client.meeting.list()
    for meeting in meetings:
        print(f"{meeting.name} (ID: {meeting.id})")

    # List meetings for a specific user
    meetings = client.meeting.list(user_id=456)

    # Get meeting details with all related data
    meeting = client.meeting.details(meeting_id=123)
    print(f"Attendees: {len(meeting.attendees)}")
    print(f"Open Issues: {len([i for i in meeting.issues if i.closed_date is None])}")
    print(f"Todos: {len(meeting.todos)}")

    # Get meeting details including closed items
    meeting = client.meeting.details(meeting_id=123, include_closed=True)

    # Get metrics for a meeting
    metrics = client.meeting.metrics(meeting_id=123)

import asyncio
from bloomy import AsyncClient

async def main():
    async with AsyncClient(api_key="your-api-key") as client:
        # List all meetings for a user
        meetings = await client.meeting.list()
        for meeting in meetings:
            print(f"{meeting.name} (ID: {meeting.id})")

        # List meetings for a specific user
        meetings = await client.meeting.list(user_id=456)

        # Get meeting details with all related data
        meeting = await client.meeting.details(meeting_id=123)
        print(f"Attendees: {len(meeting.attendees)}")
        print(f"Open Issues: {len([i for i in meeting.issues if i.closed_date is None])}")
        print(f"Todos: {len(meeting.todos)}")

        # Get meeting details including closed items
        meeting = await client.meeting.details(meeting_id=123, include_closed=True)

        # Get metrics for a meeting
        metrics = await client.meeting.metrics(meeting_id=123)

asyncio.run(main())

Creating and Deleting Meetings¶

SyncAsync

from bloomy import Client

with Client(api_key="your-api-key") as client:
    # Create a new meeting
    result = client.meeting.create(
        title="Weekly Team Meeting",
        add_self=True,
        attendees=[2, 3, 4]
    )
    print(f"Created meeting ID: {result['meeting_id']}")

    # Create a meeting without adding yourself
    result = client.meeting.create(
        title="Leadership Meeting",
        add_self=False,
        attendees=[5, 6]
    )

    # Delete a meeting
    success = client.meeting.delete(meeting_id=123)
    if success:
        print("Meeting deleted successfully")

import asyncio
from bloomy import AsyncClient

async def main():
    async with AsyncClient(api_key="your-api-key") as client:
        # Create a new meeting
        result = await client.meeting.create(
            title="Weekly Team Meeting",
            add_self=True,
            attendees=[2, 3, 4]
        )
        print(f"Created meeting ID: {result['meeting_id']}")

        # Create a meeting without adding yourself
        result = await client.meeting.create(
            title="Leadership Meeting",
            add_self=False,
            attendees=[5, 6]
        )

        # Delete a meeting
        success = await client.meeting.delete(meeting_id=123)
        if success:
            print("Meeting deleted successfully")

asyncio.run(main())

Bulk Operations¶

SyncAsync

from bloomy import Client

with Client(api_key="your-api-key") as client:
    # Batch retrieve multiple meetings
    result = client.meeting.get_many([123, 456, 789])
    for meeting in result.successful:
        print(f"{meeting.name}: {len(meeting.attendees)} attendees")
    for error in result.failed:
        print(f"Failed to retrieve meeting at index {error.index}: {error.error}")

    # Bulk create meetings
    meetings_to_create = [
        {"title": "Q1 Planning", "attendees": [2, 3]},
        {"title": "Team Standup", "add_self": True},
        {"title": "1:1 with Manager", "attendees": [5]}
    ]
    result = client.meeting.create_many(meetings_to_create)
    print(f"Created {len(result.successful)} meetings")
    for meeting in result.successful:
        print(f"Meeting ID {meeting['meeting_id']}: {meeting['title']}")

import asyncio
from bloomy import AsyncClient

async def main():
    async with AsyncClient(api_key="your-api-key") as client:
        # Batch retrieve multiple meetings (with concurrency control)
        result = await client.meeting.get_many([123, 456, 789], max_concurrent=10)
        for meeting in result.successful:
            print(f"{meeting.name}: {len(meeting.attendees)} attendees")
        for error in result.failed:
            print(f"Failed to retrieve meeting at index {error.index}: {error.error}")

        # Bulk create meetings (with concurrency control)
        meetings_to_create = [
            {"title": "Q1 Planning", "attendees": [2, 3]},
            {"title": "Team Standup", "add_self": True},
            {"title": "1:1 with Manager", "attendees": [5]}
        ]
        result = await client.meeting.create_many(
            meetings_to_create,
            max_concurrent=3
        )
        print(f"Created {len(result.successful)} meetings")
        for meeting in result.successful:
            print(f"Meeting ID {meeting['meeting_id']}: {meeting['title']}")

asyncio.run(main())

Async Concurrency Control

The async versions of get_many() and create_many() support a max_concurrent parameter to control the number of simultaneous requests. This helps prevent rate limiting and manage server load. The default is 5 concurrent requests.

Available Methods¶

Method	Description	Parameters	Returns
`list()`	Get all meetings for a user	`user_id` (optional)	`list[MeetingListItem]`
`details()`	Get detailed meeting information with attendees, issues, todos, and metrics	`meeting_id`, `include_closed` (optional, default: False)	`MeetingDetails`
`attendees()`	Get meeting attendees	`meeting_id`	`list[MeetingAttendee]`
`issues()`	Get issues from a meeting	`meeting_id`, `include_closed` (optional, default: False)	`list[Issue]`
`todos()`	Get todos from a meeting	`meeting_id`, `include_closed` (optional, default: False)	`list[Todo]`
`metrics()`	Get scorecard metrics from a meeting	`meeting_id`	`list[ScorecardMetric]`
`create()`	Create a new meeting	`title`, `add_self` (optional, default: True), `attendees` (optional)	`dict`
`delete()`	Delete a meeting	`meeting_id`	`bool`
`create_many()`	Bulk create multiple meetings	`meetings` (list of dicts), `max_concurrent` (async only, default: 5)	`BulkCreateResult[dict]`
`get_many()`	Batch retrieve multiple meetings by ID	`meeting_ids`, `max_concurrent` (async only, default: 5)	`BulkCreateResult[MeetingDetails]`