Notification

CLASS	DESCRIPTION
Notification	Python interface for Planka Notifications

Notification

Notification(schema: Schema, session: Planka)

Bases: PlankaModel[Notification]

Python interface for Planka Notifications

Returned by:

• Plankapy v2
  • models Card  Card  read_notifications
  • interface Planka Interface  interface  Planka
    •  notifications
    •  unread_notifications
    •  read_notifications

METHOD	DESCRIPTION
copy	Create a deepcopy of the model and its associated schema.
diff	Get a schema diff between two model schemas.
sync	Sync the Notification with the Planka server
update	Update the Notification

ATTRIBUTE	DESCRIPTION
__formatter__	Formatter func that allows overriding str behavior for models TYPE: ModelFormatter[Self]
action	The Action associated with the Notification TYPE: Action
board	The Board associated with the Notification (denormalized) TYPE: Board
card	The Card associated with the Notification TYPE: Card
comment	The Comment associated with the Notification TYPE: Comment
created_at	When the Notification was created TYPE: datetime
creator	The User who created the Notification TYPE: User
data	Notification specific data (varies by type) TYPE: dict[str, Any]
is_read	Whether the Notification has been read TYPE: bool
type	Type of the Notification TYPE: NotificationType
updated_at	When the Notification was last updated TYPE: datetime
user	The User who receives the Notification TYPE: User
users	All Users associated with the Notification TYPE: list[User]

Source code in src/plankapy/v2/models/_base.py

def __init__(self, schema: Schema, session: Planka) -> None:
    self._schema = schema
    self.session = session
    self.endpoints = session.endpoints
    self.client = session.client
    self.current_role = session.current_role
    self.current_id = session.current_id

__formatter__ class-attribute instance-attribute

__formatter__: ModelFormatter[Self] = DEFAULT_FORMATTER

Formatter func that allows overriding str behavior for models

action property

action: Action

The Action associated with the Notification

board property

board: Board

The Board associated with the Notification (denormalized)

card property

card: Card

The Card associated with the Notification

comment property

comment: Comment

The Comment associated with the Notification

created_at property

created_at: datetime

When the Notification was created

creator property

creator: User

The User who created the Notification

data property

data: dict[str, Any]

Notification specific data (varies by type)

is_read property writable

is_read: bool

Whether the Notification has been read

type property

type: NotificationType

Type of the Notification

updated_at property

updated_at: datetime

When the Notification was last updated

user property

user: User

The User who receives the Notification

users property

users: list[User]

All Users associated with the Notification

copy

copy() -> Self

Create a deepcopy of the model and its associated schema.

Note

Since the endpoints for both instances of the Model are the same, any calls to update will restore the state and bring both copies into sync. copies like this are meant more for comparing changes when running a sync or update/assignemnt operation.

Example:

    >>> card_copy = card.copy()
    >>> card.name = 'Updated Name'
    >>> card_copy.name
    'Original Name'
    >>> card.name
    'Updated Name'
    >>> # This update may have had side effects
    >>> print(card_copy.diff(card))
    {'name': ('Original Name', 'Updated Name'), 'updatedAt': ('...2:00pm', '...2:45pm'), ...}

Source code in src/plankapy/v2/models/_base.py

def copy(self) -> Self:
    """Create a deepcopy of the model and its associated schema.

    Note:
        Since the endpoints for both instances of the Model are the same, any 
        calls to update will restore the state and bring both copies into sync. 
        copies like this are meant more for comparing changes when running a sync 
        or update/assignemnt operation.

    Example:
    ```python
        >>> card_copy = card.copy()
        >>> card.name = 'Updated Name'
        >>> card_copy.name
        'Original Name'
        >>> card.name
        'Updated Name'
        >>> # This update may have had side effects
        >>> print(card_copy.diff(card))
        {'name': ('Original Name', 'Updated Name'), 'updatedAt': ('...2:00pm', '...2:45pm'), ...}
    ```
    """
    return copy.deepcopy(self)

diff

diff(other: PlankaModel[Schema]) -> Diff

Get a schema diff between two model schemas.

Note

Only matching keys are diffed. Any schema keys that are not in the source schema will not be checked in the target schema

Source code in src/plankapy/v2/models/_base.py

def diff(self, other: PlankaModel[Schema]) -> Diff:
    """Get a schema diff between two model schemas.

    Note:
        Only matching keys are diffed. Any schema keys that are not in the source schema 
        will not be checked in the target schema
    """
    return {
        k: (source, delta) 
        for k, source in self.schema
        if k in other.schema
        and (delta := other.schema[k]) 
        and delta != source
    }

sync

sync()

Sync the Notification with the Planka server

Source code in src/plankapy/v2/models/notification.py

def sync(self):
    """Sync the Notification with the Planka server"""
    self.schema = self.endpoints.getNotification(self.id)['item']

update

update(**kwargs: Unpack[Request_updateNotification]) -> None

Update the Notification

Source code in src/plankapy/v2/models/notification.py

def update(self, **kwargs: Unpack[paths.Request_updateNotification]) -> None:
    """Update the Notification"""
    self.schema = self.endpoints.updateNotification(self.id, **kwargs)['item']