spotifywebapiPython 1.0.242__py3-none-any.whl

spotifywebapipython/vibrant/__init__.py

@@ -0,0 +1,17 @@
+# "vibrant" namespace was imported from "vibrant-python" namespace (https://github.com/totallynotadi/vibrant-python)
+# had to import it, as the "vibrant-python" version has a dependency that was not compatible with current version of Home Assistant:
+# - "vibrant-python==0.1.6 depends on pillow>=10.1.0,<11.0.0"
+
+# import all classes from the namespace.
+from .image import VibrantImage
+from .main import Vibrant
+from .models import Palette, Props, Swatch
+from .utils import hsl_to_rgb, rgb_to_hsl
+
+# all classes to import when "import *" is specified.
+__all__ = [
+    'VibrantImage',
+    'Vibrant',
+    'Palette',
+    'Swatch',
+]

spotifywebapipython/vibrant/generator.py

@@ -0,0 +1,261 @@
+from typing import List
+
+from .models import GeneratorOpts, Palette, Swatch, hsl_to_rgb
+
+generator_opts = GeneratorOpts(
+    target_dark_luma=0.26,
+    max_dark_luma=0.45,
+    min_light_luma=0.55,
+    target_light_luma=0.74,
+    min_normal_luma=0.3,
+    target_normal_luma=0.5,
+    max_normal_luma=0.7,
+    target_muted_saturation=0.3,
+    max_muted_saturation=0.4,
+    target_vibrant_saturation=1.0,
+    min_vibrant_saturation=0.35,
+    weight_saturation=3,
+    weight_luma=6.5,
+    weight_population=0.5,
+)
+
+
+def find_max_population(swatches: List[Swatch]) -> int:
+    p = 0
+    for swatch in swatches:
+        p = max(p, swatch.population)
+    return p
+
+
+def is_already_selected(palette: Palette, swatch: Swatch) -> bool:
+    return (
+        palette.vibrant == swatch
+        or palette.dark_vibrant == swatch
+        or palette.light_vibrant == swatch
+        or palette.muted == swatch
+        or palette.dark_muted == swatch
+        or palette.light_muted == swatch
+    )
+
+
+def create_comparison_value(
+    saturation: int,
+    targetSaturation: int,
+    luma: int,
+    targetLuma: int,
+    population: int,
+    maxPopulation: int,
+    opts: GeneratorOpts,
+) -> int:
+    def weighted_mean(values: List[int]):
+        sum = 0
+        weight_sum = 0
+        for i in range(0, len(values), 2):
+            value = values[i]
+            weight = values[i + 1]
+            sum += value * weight
+            weight_sum += weight
+
+        return sum / weight_sum
+
+    def invert_diff(value: int, target_value: int) -> int:
+        return 1 - abs(value - target_value)
+
+    return weighted_mean(
+        [
+            invert_diff(saturation, targetSaturation),
+            opts.weight_saturation,
+            invert_diff(luma, targetLuma),
+            opts.weight_luma,
+            population // maxPopulation,
+            opts.weight_population,
+        ]
+    )
+
+
+def find_color_variation(
+    palette: Palette,
+    swatches: List[Swatch],
+    max_population: int,
+    target_luma: int,
+    min_luma: int,
+    max_luma: int,
+    target_saturation: int,
+    min_saturation: int,
+    max_saturation: int,
+    opts: GeneratorOpts,
+) -> Swatch:
+    max_swatch: Swatch = None
+    max_value = 0
+
+    for swatch in swatches:
+        h, s, l = swatch.hsl
+        if (
+            s >= min_saturation
+            and s <= max_saturation
+            and l >= min_luma
+            and l <= max_luma
+            and not is_already_selected(palette, swatch)
+        ):
+            value = create_comparison_value(
+                s,
+                target_saturation,
+                l,
+                target_luma,
+                swatch.population,
+                max_population,
+                opts,
+            )
+            if max_swatch == None or value > max_value:
+                max_swatch = swatch
+                max_value = value
+
+    return max_swatch
+
+
+def generate_variation_colors(
+    swatches: List[Swatch], maxPopulation: int, opts: GeneratorOpts
+) -> Palette:
+    palette: Palette = Palette()
+
+    palette.vibrant = find_color_variation(
+        palette,
+        swatches,
+        maxPopulation,
+        opts.target_normal_luma,
+        opts.min_normal_luma,
+        opts.max_normal_luma,
+        opts.target_vibrant_saturation,
+        opts.min_vibrant_saturation,
+        1,
+        opts,
+    )
+
+    palette.light_vibrant = find_color_variation(
+        palette,
+        swatches,
+        maxPopulation,
+        opts.target_light_luma,
+        opts.min_light_luma,
+        1,
+        opts.target_vibrant_saturation,
+        opts.min_vibrant_saturation,
+        1,
+        opts,
+    )
+
+    palette.dark_vibrant = find_color_variation(
+        palette,
+        swatches,
+        maxPopulation,
+        opts.target_dark_luma,
+        0,
+        opts.max_dark_luma,
+        opts.target_vibrant_saturation,
+        opts.min_vibrant_saturation,
+        1,
+        opts,
+    )
+
+    palette.muted = find_color_variation(
+        palette,
+        swatches,
+        maxPopulation,
+        opts.target_normal_luma,
+        opts.min_normal_luma,
+        opts.max_normal_luma,
+        opts.target_muted_saturation,
+        0,
+        opts.max_muted_saturation,
+        opts,
+    )
+
+    palette.light_muted = find_color_variation(
+        palette,
+        swatches,
+        maxPopulation,
+        opts.target_light_luma,
+        opts.min_light_luma,
+        1,
+        opts.target_muted_saturation,
+        0,
+        opts.max_muted_saturation,
+        opts,
+    )
+
+    palette.dark_muted = find_color_variation(
+        palette,
+        swatches,
+        maxPopulation,
+        opts.target_dark_luma,
+        0,
+        opts.max_dark_luma,
+        opts.target_muted_saturation,
+        0,
+        opts.max_muted_saturation,
+        opts,
+    )
+
+    return palette
+
+
+def generate_empty_swatches(palette: Palette, opts: GeneratorOpts) -> None:
+    if (
+        palette.vibrant is None
+        and palette.dark_vibrant is None
+        and palette.light_vibrant is None
+    ):
+        if palette.dark_vibrant is None and palette.dark_muted is not None:
+            [h, s, l] = palette.dark_muted.hsl
+            l = opts.target_dark_luma
+            palette.dark_vibrant = Swatch(hsl_to_rgb([h, s, l]), 0)
+
+        if palette.light_vibrant is None and palette.light_muted is not None:
+            [h, s, l] = palette.light_muted.hsl
+            l = opts.target_dark_luma
+            palette.dark_vibrant = Swatch(hsl_to_rgb([h, s, l]), 0)
+
+    if palette.vibrant is None and palette.dark_vibrant is not None:
+        [h, s, l] = palette.dark_vibrant.hsl
+        l = opts.target_normal_luma
+        palette.vibrant = Swatch(hsl_to_rgb([h, s, l]), 0)
+    elif palette.vibrant is None and palette.light_vibrant is not None:
+        [h, s, l] = palette.light_vibrant.hsl
+        l = opts.target_normal_luma
+        palette.vibrant = Swatch(hsl_to_rgb([h, s, l]), 0)
+
+    if palette.dark_vibrant is None and palette.vibrant is not None:
+        [h, s, l] = palette.vibrant.hsl
+        l = opts.target_dark_luma
+        palette.dark_vibrant = Swatch(hsl_to_rgb([h, s, l]), 0)
+
+    if palette.light_vibrant is None and palette.vibrant is not None:
+        [h, s, l] = palette.vibrant.hsl
+        l = opts.target_light_luma
+        palette.light_vibrant = Swatch(hsl_to_rgb([h, s, l]), 0)
+
+    if palette.muted is None and palette.vibrant is not None:
+        [h, s, l] = palette.vibrant.hsl
+        l = opts.target_muted_saturation
+        palette.muted = Swatch(hsl_to_rgb([h, s, l]), 0)
+
+    if palette.dark_muted is None and palette.dark_vibrant is not None:
+        h, s, l = palette.dark_vibrant.hsl
+        l = opts.target_muted_saturation
+        palette.dark_muted = Swatch(hsl_to_rgb([h, s, l]), 0)
+
+    if palette.light_muted is None and palette.light_vibrant is not None:
+        h, s, l = palette.light_vibrant.hsl
+        l = opts.target_muted_saturation
+        palette.light_muted = Swatch(hsl=[h, s, l], population=0)
+
+
+def generate(swatches: List[Swatch]) -> Palette:
+    max_poplation = find_max_population(swatches)
+
+    palette: Palette = generate_variation_colors(
+        swatches, max_poplation, generator_opts
+    )
+    generate_empty_swatches(palette, generator_opts)
+
+    return palette

spotifywebapipython/vibrant/image.py

@@ -0,0 +1,100 @@
+import io
+import os
+from typing import List, Optional, Tuple, Union
+import requests
+from PIL import Image
+from PIL.Image import Image as PILImage
+
+from .models import Props, Swatch
+
+
+class VibrantImage:
+    def __init__(
+        self,
+        src: Union[
+            bytes,
+            str,
+            io.BytesIO,
+            io.BufferedReader,
+            PILImage,
+            "VibrantImage",
+        ],
+        props: Optional[Props] = Props(),
+    ) -> None:
+        self.image: Image = None
+        self.props: Props = props
+
+        if isinstance(src, str):
+            if src.startswith("http"):
+                src = requests.get(src).content
+            if not os.path.exists(src):
+                raise FileNotFoundError("Image doesn't exist at given path - %s." % src)
+
+        if isinstance(src, bytes):
+            src = io.BytesIO(src)
+
+        if isinstance(src, PILImage):
+            self.image = src
+        else:
+            self.image = Image.open(src)
+
+    @classmethod
+    def from_url(cls, src: str) -> "VibrantImage":
+        src = requests.get(src).content
+        src = io.BytesIO(src)
+        return cls(Image.open(src))
+
+    @classmethod
+    def from_path(cls, src: str) -> "VibrantImage":
+        if os.path.exists(src):
+            return cls(Image.open(src))
+        raise FileNotFoundError("Image doesn't exist at given path - %s." % src)
+
+    @classmethod
+    def from_bytes(cls, src: bytes) -> "VibrantImage":
+        src = io.BytesIO(src)
+        return cls(Image.open(src))
+
+    @classmethod
+    def from_fp(cls, fp: io.BufferedReader) -> "VibrantImage":
+        return cls(Image.open(fp))
+
+    def scale_down(self):
+        ...
+
+    def _swatch_filter(self, swatch: List[int]) -> bool:
+        r, g, b = swatch.rgb
+        return not (r > 250 and g > 250 and b > 250)
+
+    def _parse_swatches(
+        self,
+        raw_swatches: List,
+        swatch_populations: List[Tuple[int, int]],
+    ) -> List[Swatch]:
+        swatches = []
+        curr_idx = 0
+        for idx in range(0, len(raw_swatches), 3):
+            if idx + 2 <= (len(raw_swatches) - 1):
+                swatches.append(
+                    Swatch(
+                        rgb=[
+                            raw_swatches[idx],
+                            raw_swatches[idx + 1],
+                            raw_swatches[idx + 2],
+                        ],
+                        population=swatch_populations[curr_idx][0],
+                    )
+                )
+                curr_idx += 1
+        return swatches
+
+    def quantize(self) -> List[Swatch]:
+        self.image = self.image.quantize(self.props.color_count)
+        raw_swatches = self.image.getpalette()
+        raw_swatches = list(filter(lambda x: x != 0, raw_swatches))
+        swatch_populations = self.image.getcolors(self.props.color_count)
+        swatches = self._parse_swatches(
+            raw_swatches=raw_swatches,
+            swatch_populations=swatch_populations,
+        )
+        return swatches

spotifywebapipython/vibrant/main.py

@@ -0,0 +1,34 @@
+import io
+from typing import Union
+
+from PIL.Image import Image as PILImage
+
+from .generator import generate
+from .image import VibrantImage
+from .models import Palette, Props
+
+
+class Vibrant:
+    props: Props
+
+    def __init__(self, color_count=64, quality=5) -> None:
+        self.props = Props(color_count=color_count, quality=quality)
+
+    def get_palette(
+        self,
+        src: Union[
+            bytes,
+            str,
+            io.BytesIO,
+            io.BufferedReader,
+            PILImage,
+            VibrantImage,
+        ],
+    ) -> Palette:
+        image = src
+        if not isinstance(src, VibrantImage):
+            image = VibrantImage(src, self.props)
+        image.scale_down()
+        swatches = image.quantize()
+        palette = generate(swatches)
+        return palette

spotifywebapipython/vibrant/models.py

@@ -0,0 +1,93 @@
+from dataclasses import dataclass
+from typing import List, Optional
+
+from .utils import hsl_to_rgb, rgb_to_hsl
+
+
+@dataclass(frozen=True)
+class Swatch:
+    rgb: List[int]
+    population: int
+    hsl: Optional[List[float]]
+
+    def __init__(self, rgb=[], population=0, hsl=[]):
+        super().__init__()
+        if rgb and not hsl:
+            object.__setattr__(self, "rgb", rgb)
+            object.__setattr__(self, "hsl", rgb_to_hsl(rgb))
+        elif hsl and not rgb:
+            object.__setattr__(self, "hsl", hsl)
+            object.__setattr__(self, "rgb", hsl_to_rgb(hsl))
+        object.__setattr__(self, "population", population)
+
+    @property
+    def rgb_hex(self) -> str:
+        """ 
+        The RGB value expressed in displayable hex string format (e.g. "#ff560a").  
+        """
+        return f"#{self.rgb[0]:02x}{self.rgb[1]:02x}{self.rgb[2]:02x}"
+
+    def ToDictionary(self) -> dict:
+        """
+        Returns a dictionary representation of the class.
+        """
+        result:dict = \
+        {
+            'rgb_hex': self.rgb_hex,
+            'rgb': self.rgb,
+            'population': self.population,
+            'hsl': self.hsl
+        }
+        return result
+
+    def ToString(self, includeTitle:bool=False) -> str:
+        """
+        Returns a displayable string representation of the class.
+        
+        Args:
+            includeTitle (str):
+                True to include the class name title prefix.
+        """
+        msg:str = ''
+        if includeTitle: 
+            msg = 'Swatch:'
+        
+        msg = '%s RGBHex="%s"' % (msg, self.rgb_hex)
+        msg = '%s RGB=%s' % (msg, str(self.rgb))
+        msg = '%s Population=%s' % (msg, str(self.population))
+        msg = '%s HSL=%s' % (msg, str(self.hsl))
+        return msg 
+
+
+@dataclass
+class Palette:
+    vibrant: Swatch = None
+    dark_vibrant: Swatch = None
+    light_vibrant: Swatch = None
+    muted: Swatch = None
+    dark_muted: Swatch = None
+    light_muted: Swatch = None
+
+
+@dataclass
+class Props:
+    color_count: int = 64
+    quality: int = 5
+
+
+@dataclass
+class GeneratorOpts:
+    target_dark_luma: int
+    max_dark_luma: int
+    min_light_luma: int
+    target_light_luma: int
+    min_normal_luma: int
+    target_normal_luma: int
+    max_normal_luma: int
+    target_muted_saturation: int
+    max_muted_saturation: int
+    target_vibrant_saturation: int
+    min_vibrant_saturation: int
+    weight_saturation: int
+    weight_luma: int
+    weight_population: int

spotifywebapipython/vibrant/utils.py

@@ -0,0 +1,56 @@
+from math import ceil
+from typing import List
+
+
+def rgb_to_hsl(rgb: List[int]) -> List[float]:
+    r, g, b = rgb
+    r /= 255
+    g /= 255
+    b /= 255
+    min_val = min(r, g, b)
+    max_val = max(r, g, b)
+
+    l = (max_val + min_val) / 2
+
+    if min_val == max_val:
+        s = 0
+    elif l <= 0.5:
+        s = (max_val - min_val) / (max_val + min_val)
+    elif l > 0.5:
+        s = (max_val - min_val) / (2.0 - max_val - min_val)
+
+    if max_val - min_val == 0:
+        h = 0
+    elif max_val == r:
+        h = ((g - b) / (max_val - min_val)) % 6
+    elif max_val == g:
+        h = (2.0) + (b - r) / (max_val - min_val)
+    else:
+        h = 4.0 + (r - g) / (max_val - min_val)
+    h = h * 60
+    h = h + 360 if h < 0 else h
+
+    return [round(val, 3) for val in (h, s, l)]
+
+
+def hsl_to_rgb(hsl: List[float]) -> List[int]:
+    h, s, l = hsl
+    c = (1 - abs((2 * l) - 1)) * s
+    x = c * (1 - abs(((h / 60) % 2) - 1))
+    m = l - c / 2
+
+    if 0 <= h < 60:
+        r, g, b = c, x, 0
+    elif 60 <= h < 120:
+        r, g, b = x, c, 0
+    elif 120 <= h < 180:
+        r, g, b = 0, c, x
+    elif 180 <= h < 240:
+        r, g, b = 0, x, c
+    elif 240 <= h < 300:
+        r, g, b = x, 0, c
+    elif 300 <= h < 360:
+        r, g, b = c, 0, x
+
+    r, g, b = (r + m) * 255, (g + m) * 255, (b + m) * 255
+    return [ceil(val) for val in (r, g, b)]

spotifywebapipython/zeroconfapi/__init__.py

@@ -0,0 +1,23 @@
+# import all classes from the namespace.
+from .authenticationtypes import AuthenticationTypes
+from .blobbuilder import BlobBuilder
+from .credentials import Credentials
+from .spotifyzeroconfapierror import SpotifyZeroconfApiError
+from .zeroconfconnect import ZeroconfConnect
+from .zeroconfresponse import ZeroconfResponse
+from .zeroconfgetinfo import ZeroconfGetInfo
+from .zeroconfgetinfoalias import ZeroconfGetInfoAlias
+from .zeroconfgetinfodrmmediaformat import ZeroconfGetInfoDrmMediaFormat
+
+# all classes to import when "import *" is specified.
+__all__ = [
+    'AuthenticationTypes',
+    'BlobBuilder', 
+    'Credentials',
+    'SpotifyZeroconfApiError',
+    'ZeroconfConnect',
+    'ZeroconfGetInfo',
+    'ZeroconfGetInfoAlias',
+    'ZeroconfGetInfoDrmMediaFormat',
+    'ZeroconfResponse',
+]

spotifywebapipython/zeroconfapi/authenticationtypes.py

@@ -0,0 +1,38 @@
+# external package imports.
+from enum import IntEnum
+
+# our package imports.
+from ..sautils import export
+
+
+@export
+class AuthenticationTypes(IntEnum):
+    """
+    Represents the type of authentication used.
+    """
+
+    USER_PASS = 0
+    """
+    UserId and Password (0x00).
+    """
+    
+    STORED_SPOTIFY_CREDENTIALS = 1
+    """
+    Spotify credentials (0x01).
+    """
+    
+    STORED_FACEBOOK_CREDENTIALS = 2
+    """
+    Facebook credentials (0x02).
+    """
+    
+    SPOTIFY_TOKEN = 3
+    """
+    Spotify authorization token (0x03).
+    """
+    
+    FACEBOOK_TOKEN = 4
+    """
+    Facebook authorization token (0x04).
+    """
+