Skip to content

Color

Color

Represents a Discord role colour. This class is similar to a (red, green, blue).

There is an alias for this called Colour.

Attributes:

Name Type Description
value int

The raw integer color value.

Operations

  • x == y: Checks if two colors are equal.

  • x != y: Checks if two colors are not equal.

  • str(x): Returns the hex format for the colour.

  • hash(x): Return the color's hash.

  • int(x): Returns the raw color value.

Source code in dismake/models/color.py 
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
class Color:
    """Represents a Discord role colour. This class is similar
    to a (red, green, blue).

    There is an alias for this called Colour.
    Attributes
    ----------
    value: int
        The raw integer color value.

    Operations
    ----------
    - ``x == y``:
        Checks if two colors are equal.

    - ``x != y``:
        Checks if two colors are not equal.

    - ``str(x)``:
        Returns the hex format for the colour.

    - ``hash(x)``:
        Return the color's hash.

    - ``int(x)``:
        Returns the raw color value.
    """

    def __init__(self, value: int) -> None:
        self.value = value

    def _get_byte(self, byte: int) -> int:
        return (self.value >> (8 * byte)) & 0xFF

    def __eq__(self, other: Any) -> bool:
        return isinstance(other, Color) and self.value == other.value

    def __ne__(self, other: Any) -> bool:
        return not self.__eq__(other)

    def __str__(self) -> str:
        return f"#{self.value:0>6x}"

    def __int__(self) -> int:
        return self.value

    def __repr__(self) -> str:
        return f"<Color value={self.value}>"

    def __hash__(self) -> int:
        return hash(self.value)

    @property
    def r(self) -> int:
        """Returns the red component of the color."""
        return self._get_byte(2)

    @property
    def g(self) -> int:
        """Returns the green component of the color."""
        return self._get_byte(1)

    @property
    def b(self) -> int:
        """Returns the blue component of the color."""
        return self._get_byte(0)

    @property
    def to_rgb(self) -> Tuple[int, int, int]:
        """Returns an (r, g, b) tuple representing the color."""
        return self.r, self.g, self.b

    @classmethod
    def default(cls: Type[CT]) -> CT:
        """A factory method that returns a ``Color`` with a value of ``0``."""
        return cls(0)

    @classmethod
    def from_rgb(cls: Type[CT], r: int, g: int, b: int) -> CT:
        """Constructs a ``Color`` from an RGB tuple."""
        return cls((r << 16) + (g << 8) + b)

    @classmethod
    def from_hsv(cls: Type[CT], h: float, s: float, v: float) -> CT:
        """Constructs a ``Color`` from an HSV tuple."""
        rgb = colorsys.hsv_to_rgb(h, s, v)
        return cls.from_rgb(*(int(x * 255) for x in rgb))

    @classmethod
    def random(
        cls: Type[CT],
        *,
        seed: Optional[Union[int, str, float, bytes, bytearray]] = None,
    ) -> CT:
        """A factory method that returns a ``Color`` with a random hue.

        Parameters
        ----------
        seed: Optional[Union[int, str, float, bytes, bytearray]]
            The seed to initialize the RNG with. If ``None`` is passed the default RNG is used.

        Note
        ----
        The random algorithm works by choosing a colour with a random hue but
        with maxed out saturation and value.
        """
        return cls.from_hsv(
            Random(seed).random() if seed is not None else random(), 1, 1
        )

    @classmethod
    def from_str(cls, value: str) -> "Color":
        """Constructs a ``Color`` from a string.

        The following formats are accepted:

        - ``0x<hex>``
        - ``#<hex>``
        - ``0x#<hex>``
        - ``rgb(<number>, <number>, <number>)``

        Like CSS, ``<number>`` can be either 0-255 or 0-100% and ``<hex>`` can be
        either a 6 digit hex number or a 3 digit hex shortcut (e.g. #FFF).

        Raises
        -------
        ValueError
            The string could not be converted into a color.
        """

        if value[0] == "#":
            return parse_hex_number(value[1:])

        if value[0:2] == "0x":
            rest = value[2:]
            # Legacy backwards compatible syntax
            if rest.startswith("#"):
                return parse_hex_number(rest[1:])
            return parse_hex_number(rest)

        arg = value.lower()
        if arg[0:3] == "rgb":
            return parse_rgb(arg)

        raise ValueError("unknown colour format given")

b property 

b: int

Returns the blue component of the color.

g property 

g: int

Returns the green component of the color.

r property 

r: int

Returns the red component of the color.

to_rgb property 

to_rgb: Tuple[int, int, int]

Returns an (r, g, b) tuple representing the color.

default classmethod 

default() -> CT

A factory method that returns a Color with a value of 0.

Source code in dismake/models/color.py 
128
129
130
131
@classmethod
def default(cls: Type[CT]) -> CT:
    """A factory method that returns a ``Color`` with a value of ``0``."""
    return cls(0)

from_hsv classmethod 

from_hsv(h: float, s: float, v: float) -> CT

Constructs a Color from an HSV tuple.

Source code in dismake/models/color.py 
138
139
140
141
142
@classmethod
def from_hsv(cls: Type[CT], h: float, s: float, v: float) -> CT:
    """Constructs a ``Color`` from an HSV tuple."""
    rgb = colorsys.hsv_to_rgb(h, s, v)
    return cls.from_rgb(*(int(x * 255) for x in rgb))

from_rgb classmethod 

from_rgb(r: int, g: int, b: int) -> CT

Constructs a Color from an RGB tuple.

Source code in dismake/models/color.py 
133
134
135
136
@classmethod
def from_rgb(cls: Type[CT], r: int, g: int, b: int) -> CT:
    """Constructs a ``Color`` from an RGB tuple."""
    return cls((r << 16) + (g << 8) + b)

from_str classmethod 

from_str(value: str) -> 'Color'

Constructs a Color from a string.

The following formats are accepted:

  • 0x<hex>
  • #<hex>
  • 0x#<hex>
  • rgb(<number>, <number>, <number>)

Like CSS, <number> can be either 0-255 or 0-100% and <hex> can be either a 6 digit hex number or a 3 digit hex shortcut (e.g. #FFF).

Raises:

Type Description
ValueError

The string could not be converted into a color.
Source code in dismake/models/color.py 
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
@classmethod
def from_str(cls, value: str) -> "Color":
    """Constructs a ``Color`` from a string.

    The following formats are accepted:

    - ``0x<hex>``
    - ``#<hex>``
    - ``0x#<hex>``
    - ``rgb(<number>, <number>, <number>)``

    Like CSS, ``<number>`` can be either 0-255 or 0-100% and ``<hex>`` can be
    either a 6 digit hex number or a 3 digit hex shortcut (e.g. #FFF).

    Raises
    -------
    ValueError
        The string could not be converted into a color.
    """

    if value[0] == "#":
        return parse_hex_number(value[1:])

    if value[0:2] == "0x":
        rest = value[2:]
        # Legacy backwards compatible syntax
        if rest.startswith("#"):
            return parse_hex_number(rest[1:])
        return parse_hex_number(rest)

    arg = value.lower()
    if arg[0:3] == "rgb":
        return parse_rgb(arg)

    raise ValueError("unknown colour format given")

random classmethod 

random(
    *,
    seed: Optional[
        Union[int, str, float, bytes, bytearray]
    ] = None
) -> CT

A factory method that returns a Color with a random hue.

Parameters:

Name Type Description Default
seed Optional[Union[int, str, float, bytes, bytearray]]

The seed to initialize the RNG with. If None is passed the default RNG is used.

 None
Note

The random algorithm works by choosing a colour with a random hue but with maxed out saturation and value.

Source code in dismake/models/color.py 
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
@classmethod
def random(
    cls: Type[CT],
    *,
    seed: Optional[Union[int, str, float, bytes, bytearray]] = None,
) -> CT:
    """A factory method that returns a ``Color`` with a random hue.

    Parameters
    ----------
    seed: Optional[Union[int, str, float, bytes, bytearray]]
        The seed to initialize the RNG with. If ``None`` is passed the default RNG is used.

    Note
    ----
    The random algorithm works by choosing a colour with a random hue but
    with maxed out saturation and value.
    """
    return cls.from_hsv(
        Random(seed).random() if seed is not None else random(), 1, 1
    )