axline ¶

def plot_to_ax(self, ax: Axes) -> None:
    """
    Plots line to matplotlib axes object.

    Args:
        ax (Axes): axes to which line should be plotted

    """
    match self.orientation:
        case LineOrientation.HORIZONTAL:
            ax.axhline(y=self.value, **self.pen.as_scatter_plot_kwargs())
        case LineOrientation.VERTICAL:
            ax.axvline(x=self.value, **self.pen.as_scatter_plot_kwargs())
        case _:
            logger.error(f"Unrecognized line orientation {self.orientation}")

def add_to_plotly(self, plotly_figure: PlotlyFigure) -> PlotlyFigure:
    """Add axis line to plotly figure without showing it in the legend"""
    match self.orientation:
        case LineOrientation.HORIZONTAL:
            plotly_figure.fig.add_hline(
                y=self.value,
                line=dict(
                    color=self.pen.rgba if self.pen else None,
                    width=self.pen.size if self.pen else None,
                    dash=(
                        self.pen._convert_linestyle_to_plotly()
                        if self.pen
                        else None
                    ),
                ),
                showlegend=False,  # Do not show in the legend
                opacity=self.pen.alpha if self.pen else None,
            )
            plotly_figure.fig.add_annotation(
                x=1.0,
                y=self.value,
                xref="paper",  # Reference to the entire plotting area
                yref="y",
                text=self.pen.label,
                showarrow=False,  # Hide the arrow if not needed
                xanchor="left",
                yanchor="middle",  # Center the text horizontally with the vline
            )
        case LineOrientation.VERTICAL:
            plotly_figure.fig.add_vline(
                x=self.value,
                line=dict(
                    color=self.pen.rgba if self.pen else None,
                    width=self.pen.size if self.pen else None,
                    dash=(
                        self.pen._convert_linestyle_to_plotly()
                        if self.pen
                        else None
                    ),
                ),
                showlegend=False,  # Do not show in the legend
                opacity=self.pen.alpha if self.pen else None,
            )
            plotly_figure.fig.add_annotation(
                x=self.value,
                y=1.0,  # Position slightly above the plot area
                yref="paper",  # Reference to the entire plotting area
                text=self.pen.label,
                showarrow=False,  # Hide the arrow if not needed
                xanchor="center",  # Center the text horizontally with the vline
                yanchor="bottom",
            )
        case _:
            logger.error(f"Unrecognized line orientation {self.orientation}")
            return plotly_figure

    return plotly_figure

def __init_subclass__(cls, **kwargs: Any) -> None:
    """
    Registers child subclasses to be able to parse them from JSON payloads using the
    [deserialize][trendify.base.record.Record.deserialize] method
    """
    super().__init_subclass__(**kwargs)
    _record_subclass_registry[cls.__name__] = cls
    logger.debug(f"Registered Record subclass {cls.__name__!r}")

def append_to_list(self, to_add_to: list) -> Self:
    """
    Appends self to list.

    Args:
        to_add_to (List): list to which `self` will be appended

    Returns:
        (Self): returns instance of `self`

    """
    to_add_to.append(self)
    return self

@classmethod
def registry(cls) -> dict[str, type[Record]]:
    """
    Returns:
        (dict[str, type[Record]]): a copy of the record_type -> class registry,
            used by the store to resolve which leaf `record_type` names correspond to a
            given (possibly non-leaf) type when filtering by `object_type`.

    """
    return dict(_record_subclass_registry)

@classmethod
def deserialize(cls, record_type: str, payload: str) -> Record:
    """
    Loads a stored JSON payload into the pydantic dataclass registered under `record_type`.

    Args:
        record_type (str): the `record_type` discriminator string (same as the class name)
        payload (str): the raw JSON text (e.g. from the store's `records.payload` column)

    Returns:
        (Record): the reconstructed, correctly-typed record instance

    """
    try:
        duck_type = _record_subclass_registry[record_type]
    except KeyError:
        logger.error(
            f"No registered Record subclass named {record_type!r}. Known types: "
            f"{sorted(_record_subclass_registry)}. This usually means the module "
            f"defining that subclass hasn't been imported in this process."
        )
        raise
    return duck_type.model_validate_json(payload)