prediction_matrix

@classmethod
def from_interaction_matrix(cls, im: InteractionMatrix) -> "PredictionMatrix":
    """Create a PredictionMatrix from an InteractionMatrix.

    :param im: The InteractionMatrix to convert.
    :type im: InteractionMatrix
    :return: A new PredictionMatrix with the same data.
    :rtype: PredictionMatrix
    """
    return cls(
        df=im._df,
        item_ix=im.ITEM_IX,
        user_ix=im.USER_IX,
        timestamp_ix=im.TIMESTAMP_IX,
        shape=getattr(im, "shape", None),
        skip_df_processing=True,
    )

def filter_for_predict(self) -> Self:
    """Get the data to be predicted.

    :return: InteractionMatrix with only the data to be predicted.
    :rtype: InteractionMatrix
    """
    return self.items_in({-1})

def mask_user_item_shape(self, shape: tuple[int, int]) -> None:
    """Masks global user and item ID.

    To ensure released matrix released to the models only contains data
    that is intended to be released. This addresses the data leakage issue.
    It is recommended that the programmer defines the shape of the matrix
    such that the model only sees the data that is intended to be seen.

    =======
    Example
    =======

    Given the following case where the data is as follows::

        > uid: [0, 1, 2, 3, 4, 5]
        > iid: [0, 1, 2, 3, -1, -1]
        > ts : [0, 1, 2, 3, 4, 6]

    Where user 4, 5 is the user to be predicted. Assuming that user 4, 5 is an
    unknown user, that is, the model has never seen user 4, 5 before. The shape
    of the matrix should be (4, 4). This should be defined when calling the
    function in :param:`shape`.

    If the shape is defined, and it contains ID of unknown user/item, a warning
    will be raised if :attr:`drop_unknown` is set to False. If :attr:`drop_unknown`
    is set to True, the unknown user/item will be dropped from the data. All
    user/item ID greater than `shape[0]` will be dropped. This follows from
    the initial assumption that the user/item ID starts from 0 as defined in
    the dataset class.

    Else, in the event that :param:`shape` is not defined, the shape will be
    inferred from the data. The shape will be determined by the number of
    unique users/items. In this case the shape will be (5, 4). Note that the
    shape may not be as intended by the programmer if the data contains
    unknown users/items or if the dataframe does not contain all historical
    users/items.

    :param shape: Shape of the known user and item base. This value is
        usually set by the evaluator during the evaluation run. This value
        can also be set manually but the programmer if there is a need to
        alter the known user/item base. Defaults to None
    :type shape: Optional[tuple[int, int]], optional
    :param drop_unknown_user: To drop unknown users in the dataset,
        defaults to False
    :type drop_unknown_user: bool, optional
    :param drop_unknown_item: To drop unknown items in the dataset,
        defaults to False
    :type drop_unknown_item: bool, optional
    :param inherit_max_id: To inherit the maximum user and item ID from the
        given shape and the dataframe. This is useful when the shape is
        defined and the dataframe contains unknown users/items. Defaults to False
    :type inherit_max_id: bool, optional
    """

    logger.debug(
        f"(user x item) shape defined is {shape}. Shape of dataframe stored in matrix was {self._df.shape} before masking"
    )
    self.user_item_shape = shape
    logger.debug(f"Final (user x item) shape defined is {self.user_item_shape}")
    self._check_user_item_shape()

def timestamps_gt(self: T, timestamp: float, inplace: bool = False) -> None | T:
    """Select interactions after a given timestamp.

    :param timestamp: The timestamp with which
        the interactions timestamp is compared.
    :type timestamp: float
    :param inplace: Apply the selection in place if True, defaults to False
    :type inplace: bool, optional
    :return: None if `inplace`, otherwise returns a new InteractionMatrix object
    :rtype: Union[InteractionMatrix, None]
    """
    return self._timestamps_cmp(operator.gt, timestamp, inplace)

def timestamps_gte(self: T, timestamp: float, inplace: bool = False) -> None | T:
    """Select interactions after and including a given timestamp.

    :param timestamp: The timestamp with which
        the interactions timestamp is compared.
    :type timestamp: float
    :param inplace: Apply the selection in place if True, defaults to False
    :type inplace: bool, optional
    :return: None if `inplace`, otherwise returns a new InteractionMatrix object
    :rtype: Union[InteractionMatrix, None]
    """
    return self._timestamps_cmp(operator.ge, timestamp, inplace)

def timestamps_lt(self: T, timestamp: float, inplace: bool = False) -> None | T:
    """Select interactions up to a given timestamp.

    :param timestamp: The timestamp with which
        the interactions timestamp is compared.
    :type timestamp: float
    :param inplace: Apply the selection in place if True, defaults to False
    :type inplace: bool, optional
    :return: None if `inplace`, otherwise returns a new InteractionMatrix object
    :rtype: Union[InteractionMatrix, None]
    """
    return self._timestamps_cmp(operator.lt, timestamp, inplace)

def timestamps_lte(self: T, timestamp: float, inplace: bool = False) -> None | T:
    """Select interactions up to and including a given timestamp.

    :param timestamp: The timestamp with which
        the interactions timestamp is compared.
    :type timestamp: float
    :param inplace: Apply the selection in place if True, defaults to False
    :type inplace: bool, optional
    :return: None if `inplace`, otherwise returns a new InteractionMatrix object
    :rtype: Union[InteractionMatrix, None]
    """
    return self._timestamps_cmp(operator.le, timestamp, inplace)

def get_users_n_last_interaction(
    self: T, n_seq_data: int = 1, t_upper: None | int = None, user_in: None | set[int] = None, inplace: bool = False
) -> T:
    return self._get_last_n_interactions(
        by=ItemUserBasedEnum.USER, n_seq_data=n_seq_data, t_upper=t_upper, id_in=user_in, inplace=inplace
    )

def get_items_n_last_interaction(
    self: T, n_seq_data: int = 1, t_upper: None | int = None, item_in: None | set[int] = None, inplace: bool = False
) -> T:
    return self._get_last_n_interactions(by=ItemUserBasedEnum.ITEM, n_seq_data=n_seq_data, t_upper=t_upper, id_in=item_in, inplace=inplace)

def get_users_n_first_interaction(
    self: T, n_seq_data: int = 1, t_lower: None | int = None, inplace: bool = False
) -> T:
    return self._get_first_n_interactions(ItemUserBasedEnum.USER, n_seq_data, t_lower, inplace)

def get_items_n_first_interaction(
    self: T, n_seq_data: int = 1, t_lower: None | int = None, inplace: bool = False
) -> T:
    return self._get_first_n_interactions(ItemUserBasedEnum.ITEM, n_seq_data, t_lower, inplace)

def users_in(self: T, U: set[int], inplace: bool = False) -> None | T:
    logger.debug("Performing users_in comparison")
    mask = self._df[self.USER_IX].isin(U)
    return self._apply_mask(mask, inplace=inplace)

def users_not_in(self: T, U: set[int], inplace: bool = False) -> None | T:
    logger.debug("Performing users_not_in comparison")
    mask = ~self._df[self.USER_IX].isin(U)
    return self._apply_mask(mask, inplace=inplace)

def items_in(self: T, id_set: set[int], inplace: bool = False) -> None | T:
    logger.debug("Performing items_in comparison")
    mask = self._df[self.ITEM_IX].isin(id_set)
    return self._apply_mask(mask, inplace=inplace)

def items_not_in(self: T, id_set: set[int], inplace: bool = False) -> None | T:
    logger.debug("Performing items_not_in comparison")
    mask = ~self._df[self.ITEM_IX].isin(id_set)
    return self._apply_mask(mask, inplace=inplace)

def copy(self) -> Self:
    """Create a deep copy of this InteractionMatrix."""
    return deepcopy(self)

def copy_df(self, reset_index: bool = False) -> "pd.DataFrame":
    """Create a deep copy of the dataframe."""
    if reset_index:
        return deepcopy(self._df.reset_index(drop=True))
    return deepcopy(self._df)

def concat(self, im: "InteractionMatrix | pd.DataFrame") -> Self:
    """Concatenate this InteractionMatrix with another.

    Note:
        This is a inplace operation. and will modify the current object.
    """
    if isinstance(im, pd.DataFrame):
        self._df = pd.concat([self._df, im])
    else:
        self._df = pd.concat([self._df, im._df])

    return self

def union(self, im: "InteractionMatrix") -> Self:
    """Combine events from this InteractionMatrix with another."""
    return self + im

def difference(self, im: "InteractionMatrix") -> Self:
    """Difference between this InteractionMatrix and another."""
    return self - im

def nonzero(self) -> tuple[list[int], list[int]]:
    return self.values.nonzero()