Card

Bases: Card_

Source code in src/plankapy/interfaces.py

class Card(Card_):

    @property 
    def _included(self) -> JSONHandler.JSONResponse:
        route = self.routes.get_card(id=self.id)
        return route()['included']


    @property
    def creator(self) -> User:
        """User that created the card

        Returns:
            User: Creator of the card
        """
        user_route = self.routes.get_user(id=self.creatorUserId)
        return User(**user_route()['item']).bind(self.routes)

    @property
    def board(self) -> Board:
        """Board the card belongs to

        Returns:
            Board: Board instance
        """
        board_route = self.routes.get_board(id=self.boardId)
        return Board(**board_route()['item']).bind(self.routes)

    @property
    def list(self) -> List:
        """List the card belongs to

        Returns:
            List: List instance
        """
        for list in self.board.lists:
            if list.id == self.listId:
                return list

    @property
    def labels(self) -> QueryableList[Label]:
        """All labels on the card

        Returns:
            Queryable List of all labels on the card
        """
        return QueryableList([
            cardLabel.label
            for cardLabel in self.board.cardLabels
            if cardLabel.cardId == self.id
        ])

    @property
    def members(self) -> QueryableList[User]:
        """All users assigned to the card

        Returns:
            Queryable List of all users assigned to the card
        """
        return QueryableList([
            cardMembership.user
            for cardMembership in self.board.cardMemberships
            if cardMembership.cardId == self.id
        ])

    @property
    def comments(self) -> QueryableList[Action]:
        """All comments on the card

        Returns:
            Queryable List of all comments on the card
        """
        route = self.routes.get_action_index(cardId=self.id)
        return QueryableList([
            Action(**action).bind(self.routes)
            for action in route()['items']
        ])

    @property
    def tasks(self) -> QueryableList[Task]:
        """All tasks on the card

        Returns:
            Queryable List of all tasks on the card
        """
        return QueryableList([
            task
            for task in self.board.tasks
            if task.cardId == self.id
        ])

    @property
    def attachments(self) -> QueryableList[Attachment]:
        """All attachments on the card

        Returns:
            Queryable List of all attachments on the card
        """
        return QueryableList(
            Attachment(**attachment).bind(self.routes)
            for attachment in self._included['attachments'])

    @property
    def due_date(self) -> datetime | None:
        """Due date of the card in datetime format

        Note:
            The `dueDate` attribute is stored as an ISO 8601 string, this property will return
            the due date as a python datetime object

        Returns:
            Due date of the card
        """
        return datetime.fromisoformat(self.dueDate) if self.dueDate else None

    def move(self, list: List) -> Card:
        """Moves the card to a new list

        Args:
            list (List): List instance to move the card to

        Returns:
            Card: The moved card instance
        """
        self.listId = list.id
        self.boardId = list.boardId
        self.update()
        return self

    def duplicate(self) -> Card:
        """Duplicates the card

        Note:
            Duplicating a card will always insert it one slot below the original card

        Returns:
            Card: The duplicated card instance
        """
        route = self.routes.post_duplicate_card(id=self.id)
        return Card(**route(**self)['item']).bind(self.routes)

    # Not currently working without a file upload endpoint
    # For this to work, we'd need to take the attacment data, post it to the filesystem,
    # Then take the response object and dumb those values (url, coverUrl) into a new
    # Attachment object then post it to the card using the `post_attachment(cardId)` route
    def add_attachment(self, file_path: Path) -> Attachment:
        """Adds an attachment to the card

        Args:
            attachment (Path | <url>): Attachment instance to add (can be a file path or url)

        Returns:
            Attachment: New attachment instance
        """
        route = self.routes.post_attachment(cardId=self.id)
        return Attachment(**route(_file=file_path)['item']).bind(self.routes)

    def add_label(self, label: Label) -> CardLabel:
        """Adds a label to the card

        Args:
            label (Label): Label instance to add

        Returns:
            CardLabel: New card label instance
        """
        route = self.routes.post_card_label(cardId=self.id)
        return CardLabel(**route(labelId=label.id, cardId=self.id)['item']).bind(self.routes)

    def add_member(self, user: User) -> CardMembership:
        """Adds a user to the card

        Args:
            user (User): User instance to add

        Returns:
            CardMembership: New card membership instance
        """
        route = self.routes.post_card_membership(cardId=self.id)
        return CardMembership(**route(userId=user.id, cardId=self.id)['item']).bind(self.routes)

    def add_comment(self, comment: str) -> Action:
        """Adds a comment to the card

        Note:
            Comments can only be added by the authenticated user, all comments made
            through plankapy will be attributed to the user in `planka.me`

        Args:
            comment (str): Comment to add

        Returns:
            Action: New comment action instance
        """
        route = self.routes.post_comment_action(cardId=self.id)        
        return Action(**route(text=comment, cardId=self.id)['item']).bind(self.routes)

    @overload
    def add_task(self, task: Task) -> Task: ...

    @overload
    def add_task(self, name: str, position: int=0, 
                 isCompleted: bool=False, isDeleted: bool=False) -> Task: ...

    def add_task(self, *args, **kwargs) -> Task:
        """Adds a task to the card

        Args:
            name (str): Name of the task (required)
            position (int): Position of the task (default: 0)
            isCompleted (bool): Whether the task is completed (default: False)
            isDeleted (bool): Whether the task is deleted (default: False)

        Args: Alternate
            task (Task): Task instance to create

        Returns:
            Task: New task instance
        """
        overload = parse_overload(
            args, kwargs, 
            model='task', 
            options=('name', 'position', 'isCompleted', 'isDeleted'), 
            required=('name',)) # Only name requires user provided value

        route = self.routes.post_task(cardId=self.id)

        # Required arguments with defaults must be manually assigned
        overload['position'] = overload.get('position', 0)
        overload['isCompleted'] = overload.get('isCompleted', False)
        overload['isDeleted'] = overload.get('isDeleted', False)

        return Task(**route(**overload)['item']).bind(self.routes)

    def add_stopwatch(self) -> Stopwatch:
        """Adds a stopwatch to the card if there is not one already

        Warning:
            The stopwatch stored in the Card instance dictionary is actually a dictionary
            that is used to update the stopwatch on Planka. When you access the stopwatch
            attribute with `card.stopwatch`, a `Stopwatch` instance is generated. This is
            an implementation detail to keep the stopwatch interface separate from the Card
            interface.

            Example:
                ```python
                >>> card.add_stopwatch()
                >>> card.stopwatch
                Stopwatch(startedAt=None, total=0)

                >>> card.__dict__['stopwatch']
                {'startedAt': None, 'total': 0}

                >>> card.stopwatch.start()
                >>> card.stopwatch
                Stopwatch(startedAt=datetime.datetime(2024, 9, 30, 0, 0, 0), total=0)

                >>> card.__dict__['stopwatch']
                {'startedAt': '2024-9-30T00:00:00Z', 'total': 0}
                ```

        Returns:
            Stopwatch: A stopwatch instance used to track time on the card
        """
        self.refresh()

        if not self.stopwatch:
            with self.editor():
                self.stopwatch = {**Stopwatch(startedAt=None, total=0).stop()}
        return self.stopwatch

    def remove_attachment(self, attachment: Attachment) -> Attachment | None:
        """Removes an attachment from the card

        Args:
            attachment (Attachment): Attachment instance to remove

        Note:
            This method will remove the attachment from the card, but the attachment itself will not be deleted

        Returns:
            Card: The card instance with the attachment removed
        """
        for card_attachment in self.attachments:
            if card_attachment.id == attachment.id:
                return card_attachment.delete()
        return None

    def remove_label(self, label: Label) -> Card:
        """Removes a label from the card

        Args:
            label (Label): Label instance to remove

        Note:
            This method will remove the label from the card, but the label itself will not be deleted

        Returns:
            Card: The card instance with the label removed   
        """
        for card_label in self.board.cardLabels:
            if card_label.cardId == self.id and card_label.labelId == label.id:
                card_label.delete()
        return self

    def remove_member(self, user: User) -> Card:
        """Removes a user from the card

        Args:
            user (User): User instance to remove

        Note:
            This method will remove the user from the card, but the user itself will not be deleted

        Returns:
            Card: The card instance with the user removed
        """
        for card_membership in self.board.cardMemberships:
            if card_membership.cardId == self.id and card_membership.userId == user.id:
                card_membership.delete()
        return self

    def remove_comment(self, comment_action: Action) -> Card:
        """Pass a comment from self.comments to remove it

        Args:
            comment_action (Action): Comment instance to remove

        Note:
            This method will remove the comment from the card, but the comment itself will not be deleted

        Returns:
            Card: The card instance with the comment removed
        """
        for comment in self.comments:
            if comment.id == comment_action.id:
                comment.delete()
        return self

    def remove_stopwatch(self) -> Stopwatch:
        """Removes the stopwatch from the card

        Returns:
            Stopwatch: The stopwatch instance that was removed
        """
        self.refresh()
        with self.editor():
            _stopwatch = self.stopwatch
            self.stopwatch = None
        return _stopwatch

    # Stopwatch handling is a bit weird, this is a hacky override to always show the user a Stopwatch instance
    def __getattribute__(self, name):
        if name == 'stopwatch':
            current = super().__getattribute__(name)
            if not current:
                current = {'startedAt':None, 'total':0}
            return Stopwatch(_card=self, **current)
        return super().__getattribute__(name)

    def __setattr__(self, name, value):
        if name == 'stopwatch' and isinstance(value, Stopwatch):
            super().__setattr__(name, dict(value))
        else:
            super().__setattr__(name, value)

    def set_due_date(self, due_date: datetime  | None) -> Card:
        """Sets the due date of the card

        Args:
            dueDate (datetime): Due date of the card (None to remove)

        Returns:
            Card: The card instance with the due date set
        """
        with self.editor():
            self.dueDate = due_date.isoformat() if due_date else None
        return self

    @overload
    def update(self) -> Card: ...

    @overload
    def update(self, card: Card) -> Card: ...

    @overload
    def update(self, name: str, position: int=0, 
                    description: str=None, dueDate: datetime=None,
                    isDueDateCompleted: bool=None,
                    stopwatch: Stopwatch=None, boardId: int=None,
                    listId: int=None, creatorUserId: int=None,
                    coverAttachmentId: int=None, isSubscribed: bool=None) -> Card: ...

    def update(self, *args, **kwargs) -> Card:
        """Updates the card with new values

        Tip:
            It's recommended to use a `card.editor()` context manager to update the card

            Example:
            ```python
            >>> with card.editor():
            ...    card.name='New Name'

            >>> card
            Card(name='New Name', ...)
            ``

        Args:
            name (str): Name of the card (optional)
            position (int): Position of the card (optional)
            description (str): Description of the card (optional)
            dueDate (datetime): Due date of the card (optional)
            isDueDateCompleted (bool): Whether the due date is completed (optional)
            stopwatch (Stopwatch): Stopwatch of the card (optional)
            boardId (int): Board id of the card (optional)
            listId (int): List id of the card (optional)
            creatorUserId (int): Creator user id of the card (optional)
            coverAttachmentId (int): Cover attachment id of the card (optional)
            isSubscribed (bool): Whether the card is subscribed (optional)

        Args: Alternate
            card (Card): Card instance to update (required)

        Note:
            If no arguments are provided, the card will update itself with the current values stored in its attributes

        Returns:
            Card: Updated card instance
        """
        overload = parse_overload(
            args, kwargs, 
            model='card', 
            options=('name', 'position', 'description', 'dueDate', 
                    'isDueDateCompleted', 'stopwatch', 
                    'creatorUserId', 'coverAttachmentId', 
                    'isSubscribed'), 
            noarg=self)

        route = self.routes.patch_card(id=self.id)
        self.__init__(**route(**overload)['item'])
        return self

    def delete(self) -> Card:
        """Deletes the card

        Danger:
            This action is irreversible and cannot be undone

        Returns:
            Card: The deleted card instance
        """
        self.refresh()
        route = self.routes.delete_card(id=self.id)
        route()
        return self

    def refresh(self):
        """Refreshes the card data

        Note:
            This method is used to update the card instance with the latest data from the server
        """
        route = self.routes.get_card(id=self.id)
        self.__init__(**route()['item'])

attachments property

All attachments on the card

Returns:

Type	Description
QueryableList[Attachment]	Queryable List of all attachments on the card

board property

Board the card belongs to

Returns:

Name	Type	Description
Board	Board	Board instance

comments property

All comments on the card

Returns:

Type	Description
QueryableList[Action]	Queryable List of all comments on the card

creator property

User that created the card

Returns:

Name	Type	Description
User	User	Creator of the card

due_date property

Due date of the card in datetime format

Note

The dueDate attribute is stored as an ISO 8601 string, this property will return the due date as a python datetime object

Returns:

Type	Description
datetime | None	Due date of the card

labels property

All labels on the card

Returns:

Type	Description
QueryableList[Label]	Queryable List of all labels on the card

list property

List the card belongs to

Returns:

Name	Type	Description
List	List	List instance

members property

All users assigned to the card

Returns:

Type	Description
QueryableList[User]	Queryable List of all users assigned to the card

tasks property

All tasks on the card

Returns:

Type	Description
QueryableList[Task]	Queryable List of all tasks on the card

add_attachment(file_path)

Adds an attachment to the card

Parameters:

Name	Type	Description	Default
attachment	Path | <url>	Attachment instance to add (can be a file path or url)	required

Returns:

Name	Type	Description
Attachment	Attachment	New attachment instance

Source code in src/plankapy/interfaces.py

def add_attachment(self, file_path: Path) -> Attachment:
    """Adds an attachment to the card

    Args:
        attachment (Path | <url>): Attachment instance to add (can be a file path or url)

    Returns:
        Attachment: New attachment instance
    """
    route = self.routes.post_attachment(cardId=self.id)
    return Attachment(**route(_file=file_path)['item']).bind(self.routes)

add_comment(comment)

Adds a comment to the card

Note

Comments can only be added by the authenticated user, all comments made through plankapy will be attributed to the user in planka.me

Parameters:

Name	Type	Description	Default
comment	str	Comment to add	required

Returns:

Name	Type	Description
Action	Action	New comment action instance

Source code in src/plankapy/interfaces.py

def add_comment(self, comment: str) -> Action:
    """Adds a comment to the card

    Note:
        Comments can only be added by the authenticated user, all comments made
        through plankapy will be attributed to the user in `planka.me`

    Args:
        comment (str): Comment to add

    Returns:
        Action: New comment action instance
    """
    route = self.routes.post_comment_action(cardId=self.id)        
    return Action(**route(text=comment, cardId=self.id)['item']).bind(self.routes)

add_label(label)

Adds a label to the card

Parameters:

Name	Type	Description	Default
label	Label	Label instance to add	required

Returns:

Name	Type	Description
CardLabel	CardLabel	New card label instance

Source code in src/plankapy/interfaces.py

def add_label(self, label: Label) -> CardLabel:
    """Adds a label to the card

    Args:
        label (Label): Label instance to add

    Returns:
        CardLabel: New card label instance
    """
    route = self.routes.post_card_label(cardId=self.id)
    return CardLabel(**route(labelId=label.id, cardId=self.id)['item']).bind(self.routes)

add_member(user)

Adds a user to the card

Parameters:

Name	Type	Description	Default
user	User	User instance to add	required

Returns:

Name	Type	Description
CardMembership	CardMembership	New card membership instance

Source code in src/plankapy/interfaces.py

def add_member(self, user: User) -> CardMembership:
    """Adds a user to the card

    Args:
        user (User): User instance to add

    Returns:
        CardMembership: New card membership instance
    """
    route = self.routes.post_card_membership(cardId=self.id)
    return CardMembership(**route(userId=user.id, cardId=self.id)['item']).bind(self.routes)

add_stopwatch()

Adds a stopwatch to the card if there is not one already

Warning

The stopwatch stored in the Card instance dictionary is actually a dictionary that is used to update the stopwatch on Planka. When you access the stopwatch attribute with card.stopwatch, a Stopwatch instance is generated. This is an implementation detail to keep the stopwatch interface separate from the Card interface.

Example:

>>> card.add_stopwatch()
>>> card.stopwatch
Stopwatch(startedAt=None, total=0)

>>> card.__dict__['stopwatch']
{'startedAt': None, 'total': 0}

>>> card.stopwatch.start()
>>> card.stopwatch
Stopwatch(startedAt=datetime.datetime(2024, 9, 30, 0, 0, 0), total=0)

>>> card.__dict__['stopwatch']
{'startedAt': '2024-9-30T00:00:00Z', 'total': 0}

Returns:

Name	Type	Description
Stopwatch	Stopwatch	A stopwatch instance used to track time on the card

Source code in src/plankapy/interfaces.py

def add_stopwatch(self) -> Stopwatch:
    """Adds a stopwatch to the card if there is not one already

    Warning:
        The stopwatch stored in the Card instance dictionary is actually a dictionary
        that is used to update the stopwatch on Planka. When you access the stopwatch
        attribute with `card.stopwatch`, a `Stopwatch` instance is generated. This is
        an implementation detail to keep the stopwatch interface separate from the Card
        interface.

        Example:
            ```python
            >>> card.add_stopwatch()
            >>> card.stopwatch
            Stopwatch(startedAt=None, total=0)

            >>> card.__dict__['stopwatch']
            {'startedAt': None, 'total': 0}

            >>> card.stopwatch.start()
            >>> card.stopwatch
            Stopwatch(startedAt=datetime.datetime(2024, 9, 30, 0, 0, 0), total=0)

            >>> card.__dict__['stopwatch']
            {'startedAt': '2024-9-30T00:00:00Z', 'total': 0}
            ```

    Returns:
        Stopwatch: A stopwatch instance used to track time on the card
    """
    self.refresh()

    if not self.stopwatch:
        with self.editor():
            self.stopwatch = {**Stopwatch(startedAt=None, total=0).stop()}
    return self.stopwatch

add_task(*args, **kwargs)

add_task(task: Task) -> Task

add_task(name: str, position: int = 0, isCompleted: bool = False, isDeleted: bool = False) -> Task

Adds a task to the card

Parameters:

Name	Type	Description	Default
name	str	Name of the task (required)	required
position	int	Position of the task (default: 0)	required
isCompleted	bool	Whether the task is completed (default: False)	required
isDeleted	bool	Whether the task is deleted (default: False)	required

Alternate

Name	Type	Description	Default
task	Task	Task instance to create	required

Returns:

Name	Type	Description
Task	Task	New task instance

Source code in src/plankapy/interfaces.py

def add_task(self, *args, **kwargs) -> Task:
    """Adds a task to the card

    Args:
        name (str): Name of the task (required)
        position (int): Position of the task (default: 0)
        isCompleted (bool): Whether the task is completed (default: False)
        isDeleted (bool): Whether the task is deleted (default: False)

    Args: Alternate
        task (Task): Task instance to create

    Returns:
        Task: New task instance
    """
    overload = parse_overload(
        args, kwargs, 
        model='task', 
        options=('name', 'position', 'isCompleted', 'isDeleted'), 
        required=('name',)) # Only name requires user provided value

    route = self.routes.post_task(cardId=self.id)

    # Required arguments with defaults must be manually assigned
    overload['position'] = overload.get('position', 0)
    overload['isCompleted'] = overload.get('isCompleted', False)
    overload['isDeleted'] = overload.get('isDeleted', False)

    return Task(**route(**overload)['item']).bind(self.routes)

delete()

Deletes the card

Danger

This action is irreversible and cannot be undone

Returns:

Name	Type	Description
Card	Card	The deleted card instance

Source code in src/plankapy/interfaces.py

def delete(self) -> Card:
    """Deletes the card

    Danger:
        This action is irreversible and cannot be undone

    Returns:
        Card: The deleted card instance
    """
    self.refresh()
    route = self.routes.delete_card(id=self.id)
    route()
    return self

duplicate()

Duplicates the card

Note

Duplicating a card will always insert it one slot below the original card

Returns:

Name	Type	Description
Card	Card	The duplicated card instance

Source code in src/plankapy/interfaces.py

def duplicate(self) -> Card:
    """Duplicates the card

    Note:
        Duplicating a card will always insert it one slot below the original card

    Returns:
        Card: The duplicated card instance
    """
    route = self.routes.post_duplicate_card(id=self.id)
    return Card(**route(**self)['item']).bind(self.routes)

move(list)

Moves the card to a new list

Parameters:

Name	Type	Description	Default
list	List	List instance to move the card to	required

Returns:

Name	Type	Description
Card	Card	The moved card instance

Source code in src/plankapy/interfaces.py

def move(self, list: List) -> Card:
    """Moves the card to a new list

    Args:
        list (List): List instance to move the card to

    Returns:
        Card: The moved card instance
    """
    self.listId = list.id
    self.boardId = list.boardId
    self.update()
    return self

refresh()

Refreshes the card data

Note

This method is used to update the card instance with the latest data from the server

Source code in src/plankapy/interfaces.py

def refresh(self):
    """Refreshes the card data

    Note:
        This method is used to update the card instance with the latest data from the server
    """
    route = self.routes.get_card(id=self.id)
    self.__init__(**route()['item'])

remove_attachment(attachment)

Removes an attachment from the card

Parameters:

Name	Type	Description	Default
attachment	Attachment	Attachment instance to remove	required

Note

This method will remove the attachment from the card, but the attachment itself will not be deleted

Returns:

Name	Type	Description
Card	Attachment | None	The card instance with the attachment removed

Source code in src/plankapy/interfaces.py

def remove_attachment(self, attachment: Attachment) -> Attachment | None:
    """Removes an attachment from the card

    Args:
        attachment (Attachment): Attachment instance to remove

    Note:
        This method will remove the attachment from the card, but the attachment itself will not be deleted

    Returns:
        Card: The card instance with the attachment removed
    """
    for card_attachment in self.attachments:
        if card_attachment.id == attachment.id:
            return card_attachment.delete()
    return None

remove_comment(comment_action)

Pass a comment from self.comments to remove it

Parameters:

Name	Type	Description	Default
comment_action	Action	Comment instance to remove	required

Note

This method will remove the comment from the card, but the comment itself will not be deleted

Returns:

Name	Type	Description
Card	Card	The card instance with the comment removed

Source code in src/plankapy/interfaces.py

def remove_comment(self, comment_action: Action) -> Card:
    """Pass a comment from self.comments to remove it

    Args:
        comment_action (Action): Comment instance to remove

    Note:
        This method will remove the comment from the card, but the comment itself will not be deleted

    Returns:
        Card: The card instance with the comment removed
    """
    for comment in self.comments:
        if comment.id == comment_action.id:
            comment.delete()
    return self

remove_label(label)

Removes a label from the card

Parameters:

Name	Type	Description	Default
label	Label	Label instance to remove	required

Note

This method will remove the label from the card, but the label itself will not be deleted

Returns:

Name	Type	Description
Card	Card	The card instance with the label removed

Source code in src/plankapy/interfaces.py

def remove_label(self, label: Label) -> Card:
    """Removes a label from the card

    Args:
        label (Label): Label instance to remove

    Note:
        This method will remove the label from the card, but the label itself will not be deleted

    Returns:
        Card: The card instance with the label removed   
    """
    for card_label in self.board.cardLabels:
        if card_label.cardId == self.id and card_label.labelId == label.id:
            card_label.delete()
    return self

remove_member(user)

Removes a user from the card

Parameters:

Name	Type	Description	Default
user	User	User instance to remove	required

Note

This method will remove the user from the card, but the user itself will not be deleted

Returns:

Name	Type	Description
Card	Card	The card instance with the user removed

Source code in src/plankapy/interfaces.py

def remove_member(self, user: User) -> Card:
    """Removes a user from the card

    Args:
        user (User): User instance to remove

    Note:
        This method will remove the user from the card, but the user itself will not be deleted

    Returns:
        Card: The card instance with the user removed
    """
    for card_membership in self.board.cardMemberships:
        if card_membership.cardId == self.id and card_membership.userId == user.id:
            card_membership.delete()
    return self

remove_stopwatch()

Removes the stopwatch from the card

Returns:

Name	Type	Description
Stopwatch	Stopwatch	The stopwatch instance that was removed

Source code in src/plankapy/interfaces.py

def remove_stopwatch(self) -> Stopwatch:
    """Removes the stopwatch from the card

    Returns:
        Stopwatch: The stopwatch instance that was removed
    """
    self.refresh()
    with self.editor():
        _stopwatch = self.stopwatch
        self.stopwatch = None
    return _stopwatch

set_due_date(due_date)

Sets the due date of the card

Parameters:

Name	Type	Description	Default
dueDate	datetime	Due date of the card (None to remove)	required

Returns:

Name	Type	Description
Card	Card	The card instance with the due date set

Source code in src/plankapy/interfaces.py

def set_due_date(self, due_date: datetime  | None) -> Card:
    """Sets the due date of the card

    Args:
        dueDate (datetime): Due date of the card (None to remove)

    Returns:
        Card: The card instance with the due date set
    """
    with self.editor():
        self.dueDate = due_date.isoformat() if due_date else None
    return self

update(*args, **kwargs)

update() -> Card

update(card: Card) -> Card

update(name: str, position: int = 0, description: str = None, dueDate: datetime = None, isDueDateCompleted: bool = None, stopwatch: Stopwatch = None, boardId: int = None, listId: int = None, creatorUserId: int = None, coverAttachmentId: int = None, isSubscribed: bool = None) -> Card

Updates the card with new values

Tip

It's recommended to use a card.editor() context manager to update the card

Example: ```python

with card.editor(): ... card.name='New Name'

card Card(name='New Name', ...) ``

Parameters:

Name	Type	Description	Default
name	str	Name of the card (optional)	required
position	int	Position of the card (optional)	required
description	str	Description of the card (optional)	required
dueDate	datetime	Due date of the card (optional)	required
isDueDateCompleted	bool	Whether the due date is completed (optional)	required
stopwatch	Stopwatch	Stopwatch of the card (optional)	required
boardId	int	Board id of the card (optional)	required
listId	int	List id of the card (optional)	required
creatorUserId	int	Creator user id of the card (optional)	required
coverAttachmentId	int	Cover attachment id of the card (optional)	required
isSubscribed	bool	Whether the card is subscribed (optional)	required

Alternate

Name	Type	Description	Default
card	Card	Card instance to update (required)	required

Note

If no arguments are provided, the card will update itself with the current values stored in its attributes

Returns:

Name	Type	Description
Card	Card	Updated card instance

Source code in src/plankapy/interfaces.py

def update(self, *args, **kwargs) -> Card:
    """Updates the card with new values

    Tip:
        It's recommended to use a `card.editor()` context manager to update the card

        Example:
        ```python
        >>> with card.editor():
        ...    card.name='New Name'

        >>> card
        Card(name='New Name', ...)
        ``

    Args:
        name (str): Name of the card (optional)
        position (int): Position of the card (optional)
        description (str): Description of the card (optional)
        dueDate (datetime): Due date of the card (optional)
        isDueDateCompleted (bool): Whether the due date is completed (optional)
        stopwatch (Stopwatch): Stopwatch of the card (optional)
        boardId (int): Board id of the card (optional)
        listId (int): List id of the card (optional)
        creatorUserId (int): Creator user id of the card (optional)
        coverAttachmentId (int): Cover attachment id of the card (optional)
        isSubscribed (bool): Whether the card is subscribed (optional)

    Args: Alternate
        card (Card): Card instance to update (required)

    Note:
        If no arguments are provided, the card will update itself with the current values stored in its attributes

    Returns:
        Card: Updated card instance
    """
    overload = parse_overload(
        args, kwargs, 
        model='card', 
        options=('name', 'position', 'description', 'dueDate', 
                'isDueDateCompleted', 'stopwatch', 
                'creatorUserId', 'coverAttachmentId', 
                'isSubscribed'), 
        noarg=self)

    route = self.routes.patch_card(id=self.id)
    self.__init__(**route(**overload)['item'])
    return self