manager_page

manager_page

Page manager for DomoCard.

DomoCard_PageManager dataclass

DomoCard_PageManager(
    auth: DomoAuth | None = None,
    parent: DomoCard_Default | None = None,
    pages: list[Any] = list(),
)

Bases: DomoRelationshipController

Manager for pages associated with a DomoCard.

add_pages async

add_pages(
    page_ids: list[str | int],
    debug_api: bool = False,
    session: AsyncClient | None = None,
    *,
    context: RouteContext | None = None,
    **context_kwargs
) -> list[Any]

Add this card to the specified pages.

Source code in src/crew_dcs/classes/DomoCard/manager_page.py

async def add_pages(
    self,
    page_ids: list[str | int],
    debug_api: bool = False,
    session: httpx.AsyncClient | None = None,
    *,
    context: RouteContext | None = None,
    **context_kwargs,
) -> list[Any]:
    """Add this card to the specified pages."""
    if not page_ids:
        raise ValueError("page_ids must be a non-empty list")

    context = RouteContext.build_context(
        context=context,
        session=session,
        debug_api=debug_api,
        debug_num_stacks_to_drop=1,
        **context_kwargs,
    )

    existing_pages = await self.get(context=context)
    existing_ids = {str(getattr(pg, "id", pg)) for pg in existing_pages}
    updated_ids = sorted({*existing_ids, *{str(pid) for pid in page_ids}})

    await card_routes.replace_card_pages(
        auth=self.auth,
        card_id=self.parent.id,
        page_ids=updated_ids,
        context=context,
    )

    return await self.get(context=context)

create_relationship async

create_relationship(
    target_entity_id: str,
    target_entity_type: EntityType,
    relationship_type: RelationshipType,
    **kwargs
) -> bool

Create a card -> page relationship by adding the card to a page.

Source code in src/crew_dcs/classes/DomoCard/manager_page.py

async def create_relationship(
    self,
    target_entity_id: str,
    target_entity_type: EntityType,
    relationship_type: RelationshipType,
    **kwargs,
) -> bool:
    """Create a card -> page relationship by adding the card to a page."""
    if relationship_type != RelationshipType.CONTAINS:
        raise ValueError(
            "Only CONTAINS relationships are supported by DomoCard_PageManager"
        )

    if target_entity_type != EntityType.PAGE:
        raise ValueError(
            "Only PAGE relationships are supported by DomoCard_PageManager"
        )

    await self.add_pages([target_entity_id], **kwargs)
    return True

get async

get(
    debug_api: bool = False,
    session: AsyncClient | None = None,
    *,
    context: RouteContext | None = None,
    **context_kwargs
) -> list[Any]

Get pages that include this card.

Source code in src/crew_dcs/classes/DomoCard/manager_page.py

async def get(
    self,
    debug_api: bool = False,
    session: httpx.AsyncClient | None = None,
    *,
    context: RouteContext | None = None,
    **context_kwargs,
) -> list[Any]:  # Returns list[DomoPage]
    """Get pages that include this card."""
    from ..DomoPage import DomoPage

    context = RouteContext.build_context(
        context=context,
        session=session,
        debug_api=debug_api,
        debug_num_stacks_to_drop=1,
        **context_kwargs,
    )

    res = await card_routes.get_card_metadata(
        auth=self.auth,
        card_id=self.parent.id,
        optional_parts="pages",
        context=context,
    )

    page_items = res.response.get("pages", [])
    if not page_items:
        self.pages = []
        self.parent.pages = []
        return []

    page_ids: list[str] = []
    for page in page_items:
        page_id = None
        if isinstance(page, dict):
            page_id = page.get("id") or page.get("pageId") or page.get("page_id")
        else:
            page_id = getattr(page, "id", None) or getattr(page, "pageId", None)

        if page_id is not None:
            page_ids.append(str(page_id))

    if not page_ids:
        self.pages = []
        self.parent.pages = []
        return []

    pages = await dmce.gather_with_concurrency(
        n=60,
        *[  # noqa: B026
            DomoPage.get_by_id(auth=self.auth, page_id=page_id, context=context)
            for page_id in page_ids
        ],
    )

    self.pages = pages
    self.parent.pages = pages

    return pages

get_direct_relationships async

get_direct_relationships() -> list[Relationship]

Get relationships between this card and its pages.

Source code in src/crew_dcs/classes/DomoCard/manager_page.py

async def get_direct_relationships(self) -> list[Relationship]:
    """Get relationships between this card and its pages."""
    pages = await self.get()
    return [
        Relationship(
            from_entity_id=str(self.parent.id),
            from_entity_type=EntityType.CARD,
            to_entity_id=str(getattr(page, "id", page)),
            to_entity_type=EntityType.PAGE,
            relationship_type=RelationshipType.CONTAINS,
            metadata={"card_id": str(self.parent.id)},
        )
        for page in pages
    ]

remove_pages async

remove_pages(
    page_ids: list[str | int],
    debug_api: bool = False,
    session: AsyncClient | None = None,
    *,
    context: RouteContext | None = None,
    **context_kwargs
) -> list[Any]

Remove this card from the specified pages.

Source code in src/crew_dcs/classes/DomoCard/manager_page.py

async def remove_pages(
    self,
    page_ids: list[str | int],
    debug_api: bool = False,
    session: httpx.AsyncClient | None = None,
    *,
    context: RouteContext | None = None,
    **context_kwargs,
) -> list[Any]:
    """Remove this card from the specified pages."""
    if not page_ids:
        raise ValueError("page_ids must be a non-empty list")

    context = RouteContext.build_context(
        context=context,
        session=session,
        debug_api=debug_api,
        debug_num_stacks_to_drop=1,
        **context_kwargs,
    )

    existing_pages = await self.get(context=context)
    existing_ids = {str(getattr(pg, "id", pg)) for pg in existing_pages}
    updated_ids = sorted(existing_ids.difference({str(pid) for pid in page_ids}))

    if not updated_ids:
        raise ValueError("Cannot remove all pages; page_ids would be empty")

    await card_routes.replace_card_pages(
        auth=self.auth,
        card_id=self.parent.id,
        page_ids=updated_ids,
        context=context,
    )

    return await self.get(context=context)

remove_relationship async

remove_relationship(
    target_entity_id: str,
    target_entity_type: EntityType,
    relationship_type: RelationshipType,
    **kwargs
) -> bool

Remove a card -> page relationship by removing the card from a page.

Source code in src/crew_dcs/classes/DomoCard/manager_page.py

async def remove_relationship(
    self,
    target_entity_id: str,
    target_entity_type: EntityType,
    relationship_type: RelationshipType,
    **kwargs,
) -> bool:
    """Remove a card -> page relationship by removing the card from a page."""
    if relationship_type != RelationshipType.CONTAINS:
        raise ValueError(
            "Only CONTAINS relationships are supported by DomoCard_PageManager"
        )

    if target_entity_type != EntityType.PAGE:
        raise ValueError(
            "Only PAGE relationships are supported by DomoCard_PageManager"
        )

    await self.remove_pages([target_entity_id], **kwargs)
    return True