Color Channels

ColorChannel = Union[PlayerColorChannel, NormalColorChannel, CopiedColorChannel] module-attribute

Represents color channels.

BaseColorChannel

Bases: RobTop

Represents base color channels.

Source code in gd/api/color_channels.py

@define()
class BaseColorChannel(RobTop):
    """Represents base color channels."""

    id: int

    @classmethod
    def from_robtop(cls, string: str) -> Self:
        data = split_color_channel(string)

        view = RobTopView(data)

        return cls.from_robtop_view(view)

    @classmethod
    def from_robtop_view(cls, view: RobTopView[int, str]) -> Self:
        id = check_color_channel_id_present(view.get_option(ID).map(int).extract())

        return cls(id=id)

    def to_robtop(self) -> str:
        return concat_color_channel(self.to_robtop_data())

    def to_robtop_data(self) -> Dict[int, str]:
        data = {ID: str(self.id)}

        return data

    def is_player(self) -> bool:
        return False

    def is_normal(self) -> bool:
        return False

    def is_copied(self) -> bool:
        return False

PlayerColorChannel

Bases: BaseColorChannel

Represents player color channels.

Source code in gd/api/color_channels.py

@define()
class PlayerColorChannel(BaseColorChannel):
    """Represents player color channels."""

    player_color: PlayerColor

    opacity: float = DEFAULT_OPACITY

    blending: bool = DEFAULT_BLENDING

    def is_blending(self) -> bool:
        return self.blending

    @classmethod
    def from_robtop_view(cls, view: RobTopView[int, str]) -> Self:
        id = check_color_channel_id_present(view.get_option(ID).map(int).extract())

        player_color = (
            view.get_option(PLAYER_COLOR).map(int).map(PlayerColor).unwrap_or(PlayerColor.DEFAULT)
        )

        opacity = view.get_option(OPACITY).map(float).unwrap_or(DEFAULT_OPACITY)

        blending = view.get_option(BLENDING).map(int_bool).unwrap_or(DEFAULT_BLENDING)

        return cls(id=id, player_color=player_color, opacity=opacity, blending=blending)

    def to_robtop_data(self) -> Dict[int, str]:
        data = super().to_robtop_data()

        here = {
            PLAYER_COLOR: str(self.player_color.value),
            OPACITY: float_str(self.opacity),
            OPACITY_TOGGLED: bool_str(DEFAULT_OPACITY_TOGGLED),
        }

        data.update(here)

        blending = self.is_blending()

        if blending:
            data[BLENDING] = bool_str(blending)

        return data

    def is_player(self) -> bool:
        return True

NormalColorChannel

Bases: BaseColorChannel

Represents normal color channels.

Source code in gd/api/color_channels.py

@define()
class NormalColorChannel(BaseColorChannel):
    """Represents normal color channels."""

    color: Color

    opacity: float = DEFAULT_OPACITY

    blending: bool = DEFAULT_BLENDING

    def is_blending(self) -> bool:
        return self.blending

    @classmethod
    def from_robtop_view(cls, view: RobTopView[int, str]) -> Self:
        id = check_color_channel_id_present(view.get_option(ID).map(int).extract())

        red = view.get_option(RED).map(int).unwrap_or(DEFAULT_RED)
        green = view.get_option(GREEN).map(int).unwrap_or(DEFAULT_GREEN)
        blue = view.get_option(BLUE).map(int).unwrap_or(DEFAULT_BLUE)

        color = Color.from_rgb(red, green, blue)

        opacity = view.get_option(OPACITY).map(float).unwrap_or(DEFAULT_OPACITY)

        blending = view.get_option(BLENDING).map(int_bool).unwrap_or(DEFAULT_BLENDING)

        return cls(id=id, color=color, opacity=opacity, blending=blending)

    def to_robtop_data(self) -> Dict[int, str]:
        data = super().to_robtop_data()

        color = self.color

        here = {
            RED: str(color.red),
            GREEN: str(color.green),
            BLUE: str(color.blue),
            OPACITY: float_str(self.opacity),
            OPACITY_TOGGLED: bool_str(DEFAULT_OPACITY_TOGGLED),
        }

        data.update(here)

        blending = self.is_blending()

        if blending:
            data[BLENDING] = bool_str(blending)

        return data

    def is_normal(self) -> bool:
        return True

CopiedColorChannel

Bases: BaseColorChannel

Represents copied color channels.

Source code in gd/api/color_channels.py

@define()
class CopiedColorChannel(BaseColorChannel):
    """Represents copied color channels."""

    copied_id: int = field()

    hsv: HSV = field(factory=HSV)

    opacity: Optional[float] = field(default=None)

    blending: bool = field(default=DEFAULT_BLENDING)

    def is_blending(self) -> bool:
        return self.blending

    @classmethod
    def from_robtop_view(cls, view: RobTopView[int, str]) -> Self:
        id = check_color_channel_id_present(view.get_option(ID).map(int).extract())

        copied_id = check_color_channel_copied_id_present(
            view.get_option(COPIED_ID).map(int).extract()
        )

        hsv = view.get_option(COLOR_HSV).map(HSV.from_robtop).unwrap_or_else(HSV)

        copy_opacity = view.get_option(COPY_OPACITY).map(int_bool).unwrap_or(DEFAULT_COPY_OPACITY)

        if copy_opacity:
            opacity = None

        else:
            opacity = view.get_option(OPACITY).map(float).unwrap_or(DEFAULT_OPACITY)

        blending = view.get_option(BLENDING).map(int_bool).unwrap_or(DEFAULT_BLENDING)

        return cls(id=id, copied_id=copied_id, hsv=hsv, opacity=opacity, blending=blending)

    def to_robtop_data(self) -> Dict[int, str]:
        data = super().to_robtop_data()

        copy_opacity = self.is_copy_opacity()

        here = {
            COPIED_ID: str(self.copied_id),
            COLOR_HSV: self.hsv.to_robtop(),
            COPY_OPACITY: bool_str(copy_opacity),
            OPACITY_TOGGLED: bool_str(DEFAULT_OPACITY_TOGGLED),
        }

        data.update(here)

        if not copy_opacity:
            data[OPACITY] = float_str(self.opacity_checked)

        blending = self.is_blending()

        if blending:
            data[BLENDING] = bool_str(blending)

        return data

    def is_copied(self) -> bool:
        return True

    @property
    def opacity_checked(self) -> float:
        opacity = self.opacity

        if opacity is None:
            raise ValueError(COPIED_OPACITY)

        return opacity

    def is_copy_opacity(self) -> bool:
        return self.opacity is None

    def copy_opacity(self) -> Self:
        self.opacity = None

        return self

ColorChannels

Bases: Dict[int, ColorChannel]

Represents collections of color channels.

Source code in gd/api/color_channels.py

class ColorChannels(Dict[int, ColorChannel]):
    """Represents collections of color channels."""

    def copy(self) -> Self:
        return type(self)(self)

    @classmethod
    def from_color_channel_iterable(cls, color_channels: Iterable[ColorChannel]) -> Self:
        return cls({color_channel.id: color_channel for color_channel in color_channels})

    @classmethod
    def from_color_channels(cls, *color_channels: ColorChannel) -> Self:
        return cls.from_color_channel_iterable(color_channels)

    @property
    def length(self) -> int:
        return len(self)

    def add(self, color_channel: ColorChannel) -> None:
        self[color_channel.id] = color_channel

    @classmethod
    def from_robtop(cls, string: str) -> Self:
        return cls.from_color_channel_iterable(
            iter(split_color_channels(string)).filter(None).map(color_channel_from_robtop).unwrap()
        )

    def to_robtop(self) -> str:
        return concat_color_channels(map(color_channel_to_robtop, self.values()))