alexa_media_player: Alexa Media Player fails to initialize after restarting HA 2024.6.3 due to partitioned cookie

IMPORTANT: Please search the issues, including closed issues, and the FAQ before opening a new issue. The template is mandatory; failure to use it will result in issue closure.

Describe the bug

Alexa Media Player is failing to initialize after restarting HA 2024.6.3. If I reload the integration, all is well.

To Reproduce

Restart Home assistant 2014.6.3 and observe that the integration failed to load.

Expected behavior

It should load like it did on 2024.6.2 and older.

Screenshots

image

System details

  • Home-assistant (version): 2024.6.3
  • alexa_media (version from const.py or HA startup): 4.10.2
  • alexapy (version from pip show alexapy or HA startup):
- alexa_media # pip show alexapy
WARNING: Package(s) not found: alexapy

Logs

home-assistant_2024-06-17T13-08-27.618Z.log

Additional context

About this issue

  • Original URL
  • State: closed
  • Created 2 years ago
  • Reactions: 22
  • Comments: 193 (12 by maintainers)

Commits related to this issue

Most upvoted comments

I also have this issue. The integration fails to start every time I restart HA. And it succeed to load by reloading the integration. The error is always

Traceback (most recent call last):
  File "/usr/src/homeassistant/homeassistant/config_entries.py", line 594, in async_setup
    result = await component.async_setup_entry(hass, self)
             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "/config/custom_components/alexa_media/__init__.py", line 335, in async_setup_entry
    await login.login(cookies=await login.load_cookie())
                              ^^^^^^^^^^^^^^^^^^^^^^^^^
  File "/usr/local/lib/python3.12/site-packages/alexapy/alexalogin.py", line 328, in load_cookie
    cookies = pickle.loads(await myfile.read())
              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "/usr/local/lib/python3.12/http/cookies.py", line 312, in __setitem__
    raise CookieError("Invalid attribute %r" % (K,))
http.cookies.CookieError: Invalid attribute 'partitioned'

The issue started about 1-2 weeks ago. I never experienced this before.

Thanks, I’ve submitted my PR. @alandtse Please see https://gitlab.com/keatontaylor/alexapy/-/merge_requests/376

I’m gonna go have a beer (or two) to celebrate…

I have the same issue, I need to manually reload integration after each restart, reload seems to work each time.

***NEW DEVELOPMENT ***

The cutoff for new features in Python 3.13 was at the beginning of the beta cycle on 2024-05-08. Python new features won’t happen again now until 3.14 but the partitioned cookie PR might get looked at as “type-security/bug fix”.
Ref: gh-112713 : Add support for ‘partitioned’ attribute in http.cookies #112714

In the midst of the above, I went hunting again and found a PR from 3 weeks ago for the Unifi add-on which which also has/had partitioned cookie trouble. That PR was Bump aiounifi to v80 #124004. aiounifi is a library much like alexapy. I went looking through the aiounifi library and found code in connectivity.py that resolves the partitioned cookie issue:

if sys.version_info[:2] < (3, 13):
    from http import cookies

    # See: https://github.com/python/cpython/issues/112713
    cookies.Morsel._reserved["partitioned"] = "partitioned"  # type: ignore[attr-defined]
    cookies.Morsel._flags.add("partitioned")  # type: ignore[attr-defined]

I added that code to alexapy/alexalogin.py and it eliminated the partitioned cookie error in python3.12/http/cookies.py. I’ve submitted alexapy merge request: #386

Changed back to original cookies.py and restart HA: Problem exists. Changed alexalogin.py and restart HA: no Problems Second restart: no Problems Thrid restart: no Problems

My workaround for now is this automation:

alias: Reload Alexa Media Player after HA starts
description: ""
trigger:
  - platform: homeassistant
    event: start
condition: []
action:
  - delay:
      hours: 0
      minutes: 1
      seconds: 0
      milliseconds: 0
  - alias: Reload Alexa Media Player integration
    service: homeassistant.reload_config_entry
    data: {}
    target:
      entity_id: media_player.bedroom
    enabled: true
mode: single

alexapy version 1.29.2 is released and has resolved the partitioned cookie error! Edit your manifest.json to:

{
  "domain": "alexa_media",
  "name": "Alexa Media Player",
  "codeowners": ["@alandtse", "@keatontaylor"],
  "config_flow": true,
  "dependencies": ["persistent_notification", "http"],
  "documentation": "https://github.com/alandtse/alexa_media_player/wiki",
  "iot_class": "cloud_polling",
  "issue_tracker": "https://github.com/alandtse/alexa_media_player/issues",
  "loggers": ["alexapy", "authcaptureproxy"],
  "requirements": ["alexapy==1.29.2", "packaging>=20.3", "wrapt>=1.14.0"],
  "version": "4.12.12"
}

i’m waiting for your instructions. thanks for that! i’ll probably break something on my own 😉

Here goes…

  • HACS > Add custom repository > https://github.com/amitfin/patch, Category: Integration
  • Select the newly added integration in HACS and select download.
  • Restart HA
  • Create a shared folder, the contents of which is untouched by and survives an HA update. I used my Synology NAS with a share name patch and added that shared folder to Setting > System > Storage > Network storage as patches. That creates a folder in Home Assistant /share/ named patches. Alternatively, you can just create the /share/patches folder which will then reside on your HA storage device.
  • Populate it with the contents from this cookies_patch.zip
  • Add this block to configuration.yaml file:
patch:
  delay: 10
  files:
    - name: cookies.py
      base: /share/patches/python3.12/http
      destination: "/usr/local/lib/python3.12/http"
      patch: /share/patches/python3.13/http
  • Restart HA and that should be it.

image

image

image

image

Ok the tone is getting out of hand. Please remember there are human beings at the other end of the pipes.

As @danielbrunt57 is volunteering to respond to issues and provide code, I’ve been deferring to him on the close decision frankly because I’m not following the issues closely. I was actually about to provide him contributor privileges to do it without asking me.

That said, we can leave this open. But please keep things civil. I don’t have time or the interest to come moderate disputes.

If you’re concerned about the integration dying, consider helping out with code, translations, or responding to issues. Otherwise I could see @danielbrunt57 deciding to just avoid the trouble completely.

Hacking the code inside the HA docker needed to be repeated every time you upgrade HA. Having an automation to reload after 1 minute. Works. Is horrible. Waiting until October where HA Maybe upgrades Python and that will maybe fix it (we cannot be sure)

Why can’t this component be modified so it delays its loading so it works for everyone. All users that do not see this bug report will have no clue. And when you close it - it becomes practically invisible. Users will have an issue, come here to look for open bugs. Find none. Is this component only for geeks?

I do not personally trust that this custom component will exist much longer.

I’ve found a solution which is working for me. My issue seems to be in alexapy which is using python 3.12. It’s cookies.py does not define partitioned in the cookie dictionary, which for some reason is what my setup is encountering during first initialization after restart but not during a reload. I found this PR: gh-112713 : Add support for ‘partitioned’ attribute in http.cookies #112714 which has been approved for python 3.13 but hasn’t been finalized yet and still has to go through several betas before official ETA release in October. This would seem to be needed now as MS Edge (my default browser) seems to already be creating partitioned cookies (CHIPS) and I’ve read that Google Chrome recently started rolling it out as well.

First, edit config/custom_components/alexa_media/manifest.json and add “websocket_api” to “dependencies”:

{
  "domain": "alexa_media",
  "name": "Alexa Media Player",
  "codeowners": ["@alandtse", "@keatontaylor"],
  "config_flow": true,
  "dependencies": ["persistent_notification", "http", "websocket_api"],
  "documentation": "https://github.com/alandtse/alexa_media_player/wiki",
  "iot_class": "cloud_polling",
  "issue_tracker": "https://github.com/alandtse/alexa_media_player/issues",
  "loggers": ["alexapy", "authcaptureproxy"],
  "requirements": ["alexapy==1.27.10", "packaging>=20.3", "wrapt>=1.14.0"],
  "version": "4.10.2"
}

Then, in the homeassistant container, I replaced /usr/local/lib/python3.12/http/cookies.py with the newer python3.13 cookies.py file from https://github.com/giles-v/cpython/blob/add-cookies-partitioned-support/Lib/http/cookies.py (Line 285 is where “partitioned” has been added to the cookie dictionary):

####
# Copyright 2000 by Timothy O'Malley <timo@alum.mit.edu>
#
#                All Rights Reserved
#
# Permission to use, copy, modify, and distribute this software
# and its documentation for any purpose and without fee is hereby
# granted, provided that the above copyright notice appear in all
# copies and that both that copyright notice and this permission
# notice appear in supporting documentation, and that the name of
# Timothy O'Malley  not be used in advertising or publicity
# pertaining to distribution of the software without specific, written
# prior permission.
#
# Timothy O'Malley DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS
# SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
# AND FITNESS, IN NO EVENT SHALL Timothy O'Malley BE LIABLE FOR
# ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
# WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
# ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
# PERFORMANCE OF THIS SOFTWARE.
#
####
#
# Id: Cookie.py,v 2.29 2000/08/23 05:28:49 timo Exp
#   by Timothy O'Malley <timo@alum.mit.edu>
#
#  Cookie.py is a Python module for the handling of HTTP
#  cookies as a Python dictionary.  See RFC 2109 for more
#  information on cookies.
#
#  The original idea to treat Cookies as a dictionary came from
#  Dave Mitchell (davem@magnet.com) in 1995, when he released the
#  first version of nscookie.py.
#
####

r"""
Here's a sample session to show how to use this module.
At the moment, this is the only documentation.

The Basics
----------

Importing is easy...

   >>> from http import cookies

Most of the time you start by creating a cookie.

   >>> C = cookies.SimpleCookie()

Once you've created your Cookie, you can add values just as if it were
a dictionary.

   >>> C = cookies.SimpleCookie()
   >>> C["fig"] = "newton"
   >>> C["sugar"] = "wafer"
   >>> C.output()
   'Set-Cookie: fig=newton\r\nSet-Cookie: sugar=wafer'

Notice that the printable representation of a Cookie is the
appropriate format for a Set-Cookie: header.  This is the
default behavior.  You can change the header and printed
attributes by using the .output() function

   >>> C = cookies.SimpleCookie()
   >>> C["rocky"] = "road"
   >>> C["rocky"]["path"] = "/cookie"
   >>> print(C.output(header="Cookie:"))
   Cookie: rocky=road; Path=/cookie
   >>> print(C.output(attrs=[], header="Cookie:"))
   Cookie: rocky=road

The load() method of a Cookie extracts cookies from a string.  In a
CGI script, you would use this method to extract the cookies from the
HTTP_COOKIE environment variable.

   >>> C = cookies.SimpleCookie()
   >>> C.load("chips=ahoy; vienna=finger")
   >>> C.output()
   'Set-Cookie: chips=ahoy\r\nSet-Cookie: vienna=finger'

The load() method is darn-tootin smart about identifying cookies
within a string.  Escaped quotation marks, nested semicolons, and other
such trickeries do not confuse it.

   >>> C = cookies.SimpleCookie()
   >>> C.load('keebler="E=everybody; L=\\"Loves\\"; fudge=\\012;";')
   >>> print(C)
   Set-Cookie: keebler="E=everybody; L=\"Loves\"; fudge=\012;"

Each element of the Cookie also supports all of the RFC 2109
Cookie attributes.  Here's an example which sets the Path
attribute.

   >>> C = cookies.SimpleCookie()
   >>> C["oreo"] = "doublestuff"
   >>> C["oreo"]["path"] = "/"
   >>> print(C)
   Set-Cookie: oreo=doublestuff; Path=/

Each dictionary element has a 'value' attribute, which gives you
back the value associated with the key.

   >>> C = cookies.SimpleCookie()
   >>> C["twix"] = "none for you"
   >>> C["twix"].value
   'none for you'

The SimpleCookie expects that all values should be standard strings.
Just to be sure, SimpleCookie invokes the str() builtin to convert
the value to a string, when the values are set dictionary-style.

   >>> C = cookies.SimpleCookie()
   >>> C["number"] = 7
   >>> C["string"] = "seven"
   >>> C["number"].value
   '7'
   >>> C["string"].value
   'seven'
   >>> C.output()
   'Set-Cookie: number=7\r\nSet-Cookie: string=seven'

Finis.
"""

#
# Import our required modules
#
import re
import string
import types

__all__ = ["CookieError", "BaseCookie", "SimpleCookie"]

_nulljoin = ''.join
_semispacejoin = '; '.join
_spacejoin = ' '.join

#
# Define an exception visible to External modules
#
class CookieError(Exception):
    pass


# These quoting routines conform to the RFC2109 specification, which in
# turn references the character definitions from RFC2068.  They provide
# a two-way quoting algorithm.  Any non-text character is translated
# into a 4 character sequence: a forward-slash followed by the
# three-digit octal equivalent of the character.  Any '\' or '"' is
# quoted with a preceding '\' slash.
# Because of the way browsers really handle cookies (as opposed to what
# the RFC says) we also encode "," and ";".
#
# These are taken from RFC2068 and RFC2109.
#       _LegalChars       is the list of chars which don't require "'s
#       _Translator       hash-table for fast quoting
#
_LegalChars = string.ascii_letters + string.digits + "!#$%&'*+-.^_`|~:"
_UnescapedChars = _LegalChars + ' ()/<=>?@[]{}'

_Translator = {n: '\\%03o' % n
               for n in set(range(256)) - set(map(ord, _UnescapedChars))}
_Translator.update({
    ord('"'): '\\"',
    ord('\\'): '\\\\',
})

_is_legal_key = re.compile('[%s]+' % re.escape(_LegalChars)).fullmatch

def _quote(str):
    r"""Quote a string for use in a cookie header.

    If the string does not need to be double-quoted, then just return the
    string.  Otherwise, surround the string in doublequotes and quote
    (with a \) special characters.
    """
    if str is None or _is_legal_key(str):
        return str
    else:
        return '"' + str.translate(_Translator) + '"'


_OctalPatt = re.compile(r"\\[0-3][0-7][0-7]")
_QuotePatt = re.compile(r"[\\].")

def _unquote(str):
    # If there aren't any doublequotes,
    # then there can't be any special characters.  See RFC 2109.
    if str is None or len(str) < 2:
        return str
    if str[0] != '"' or str[-1] != '"':
        return str

    # We have to assume that we must decode this string.
    # Down to work.

    # Remove the "s
    str = str[1:-1]

    # Check for special sequences.  Examples:
    #    \012 --> \n
    #    \"   --> "
    #
    i = 0
    n = len(str)
    res = []
    while 0 <= i < n:
        o_match = _OctalPatt.search(str, i)
        q_match = _QuotePatt.search(str, i)
        if not o_match and not q_match:              # Neither matched
            res.append(str[i:])
            break
        # else:
        j = k = -1
        if o_match:
            j = o_match.start(0)
        if q_match:
            k = q_match.start(0)
        if q_match and (not o_match or k < j):     # QuotePatt matched
            res.append(str[i:k])
            res.append(str[k+1])
            i = k + 2
        else:                                      # OctalPatt matched
            res.append(str[i:j])
            res.append(chr(int(str[j+1:j+4], 8)))
            i = j + 4
    return _nulljoin(res)

# The _getdate() routine is used to set the expiration time in the cookie's HTTP
# header.  By default, _getdate() returns the current time in the appropriate
# "expires" format for a Set-Cookie header.  The one optional argument is an
# offset from now, in seconds.  For example, an offset of -3600 means "one hour
# ago".  The offset may be a floating point number.
#

_weekdayname = ['Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun']

_monthname = [None,
              'Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun',
              'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec']

def _getdate(future=0, weekdayname=_weekdayname, monthname=_monthname):
    from time import gmtime, time
    now = time()
    year, month, day, hh, mm, ss, wd, y, z = gmtime(now + future)
    return "%s, %02d %3s %4d %02d:%02d:%02d GMT" % \
           (weekdayname[wd], day, monthname[month], year, hh, mm, ss)


class Morsel(dict):
    """A class to hold ONE (key, value) pair.

    In a cookie, each such pair may have several attributes, so this class is
    used to keep the attributes associated with the appropriate key,value pair.
    This class also includes a coded_value attribute, which is used to hold
    the network representation of the value.
    """
    # RFC 2109 lists these attributes as reserved:
    #   path       comment         domain
    #   max-age    secure      version
    #
    # For historical reasons, these attributes are also reserved:
    #   expires
    #
    # This is an extension from Microsoft:
    #   httponly
    #
    # This dictionary provides a mapping from the lowercase
    # variant on the left to the appropriate traditional
    # formatting on the right.
    _reserved = {
        "expires": "expires",
        "path": "Path",
        "comment": "Comment",
        "domain": "Domain",
        "max-age": "Max-Age",
        "secure": "Secure",
        "httponly": "HttpOnly",
        "version": "Version",
        "samesite": "SameSite",
        "partitioned": "Partitioned",
    }

    _flags = {'secure', 'httponly', 'partitioned'}

    def __init__(self):
        # Set defaults
        self._key = self._value = self._coded_value = None

        # Set default attributes
        for key in self._reserved:
            dict.__setitem__(self, key, "")

    @property
    def key(self):
        return self._key

    @property
    def value(self):
        return self._value

    @property
    def coded_value(self):
        return self._coded_value

    def __setitem__(self, K, V):
        K = K.lower()
        if not K in self._reserved:
            raise CookieError("Invalid attribute %r" % (K,))
        dict.__setitem__(self, K, V)

    def setdefault(self, key, val=None):
        key = key.lower()
        if key not in self._reserved:
            raise CookieError("Invalid attribute %r" % (key,))
        return dict.setdefault(self, key, val)

    def __eq__(self, morsel):
        if not isinstance(morsel, Morsel):
            return NotImplemented
        return (dict.__eq__(self, morsel) and
                self._value == morsel._value and
                self._key == morsel._key and
                self._coded_value == morsel._coded_value)

    __ne__ = object.__ne__

    def copy(self):
        morsel = Morsel()
        dict.update(morsel, self)
        morsel.__dict__.update(self.__dict__)
        return morsel

    def update(self, values):
        data = {}
        for key, val in dict(values).items():
            key = key.lower()
            if key not in self._reserved:
                raise CookieError("Invalid attribute %r" % (key,))
            data[key] = val
        dict.update(self, data)

    def isReservedKey(self, K):
        return K.lower() in self._reserved

    def set(self, key, val, coded_val):
        if key.lower() in self._reserved:
            raise CookieError('Attempt to set a reserved key %r' % (key,))
        if not _is_legal_key(key):
            raise CookieError('Illegal key %r' % (key,))

        # It's a good key, so save it.
        self._key = key
        self._value = val
        self._coded_value = coded_val

    def __getstate__(self):
        return {
            'key': self._key,
            'value': self._value,
            'coded_value': self._coded_value,
        }

    def __setstate__(self, state):
        self._key = state['key']
        self._value = state['value']
        self._coded_value = state['coded_value']

    def output(self, attrs=None, header="Set-Cookie:"):
        return "%s %s" % (header, self.OutputString(attrs))

    __str__ = output

    def __repr__(self):
        return '<%s: %s>' % (self.__class__.__name__, self.OutputString())

    def js_output(self, attrs=None):
        # Print javascript
        return """
        <script type="text/javascript">
        <!-- begin hiding
        document.cookie = \"%s\";
        // end hiding -->
        </script>
        """ % (self.OutputString(attrs).replace('"', r'\"'))

    def OutputString(self, attrs=None):
        # Build up our result
        #
        result = []
        append = result.append

        # First, the key=value pair
        append("%s=%s" % (self.key, self.coded_value))

        # Now add any defined attributes
        if attrs is None:
            attrs = self._reserved
        items = sorted(self.items())
        for key, value in items:
            if value == "":
                continue
            if key not in attrs:
                continue
            if key == "expires" and isinstance(value, int):
                append("%s=%s" % (self._reserved[key], _getdate(value)))
            elif key == "max-age" and isinstance(value, int):
                append("%s=%d" % (self._reserved[key], value))
            elif key == "comment" and isinstance(value, str):
                append("%s=%s" % (self._reserved[key], _quote(value)))
            elif key in self._flags:
                if value:
                    append(str(self._reserved[key]))
            else:
                append("%s=%s" % (self._reserved[key], value))

        # Return the result
        return _semispacejoin(result)

    __class_getitem__ = classmethod(types.GenericAlias)


#
# Pattern for finding cookie
#
# This used to be strict parsing based on the RFC2109 and RFC2068
# specifications.  I have since discovered that MSIE 3.0x doesn't
# follow the character rules outlined in those specs.  As a
# result, the parsing rules here are less strict.
#

_LegalKeyChars  = r"\w\d!#%&'~_`><@,:/\$\*\+\-\.\^\|\)\(\?\}\{\="
_LegalValueChars = _LegalKeyChars + r'\[\]'
_CookiePattern = re.compile(r"""
    \s*                            # Optional whitespace at start of cookie
    (?P<key>                       # Start of group 'key'
    [""" + _LegalKeyChars + r"""]+?   # Any word of at least one letter
    )                              # End of group 'key'
    (                              # Optional group: there may not be a value.
    \s*=\s*                          # Equal Sign
    (?P<val>                         # Start of group 'val'
    "(?:[^\\"]|\\.)*"                  # Any doublequoted string
    |                                  # or
    \w{3},\s[\w\d\s-]{9,11}\s[\d:]{8}\sGMT  # Special case for "expires" attr
    |                                  # or
    [""" + _LegalValueChars + r"""]*      # Any word or empty string
    )                                # End of group 'val'
    )?                             # End of optional value group
    \s*                            # Any number of spaces.
    (\s+|;|$)                      # Ending either at space, semicolon, or EOS.
    """, re.ASCII | re.VERBOSE)    # re.ASCII may be removed if safe.


# At long last, here is the cookie class.  Using this class is almost just like
# using a dictionary.  See this module's docstring for example usage.
#
class BaseCookie(dict):
    """A container class for a set of Morsels."""

    def value_decode(self, val):
        """real_value, coded_value = value_decode(STRING)
        Called prior to setting a cookie's value from the network
        representation.  The VALUE is the value read from HTTP
        header.
        Override this function to modify the behavior of cookies.
        """
        return val, val

    def value_encode(self, val):
        """real_value, coded_value = value_encode(VALUE)
        Called prior to setting a cookie's value from the dictionary
        representation.  The VALUE is the value being assigned.
        Override this function to modify the behavior of cookies.
        """
        strval = str(val)
        return strval, strval

    def __init__(self, input=None):
        if input:
            self.load(input)

    def __set(self, key, real_value, coded_value):
        """Private method for setting a cookie's value"""
        M = self.get(key, Morsel())
        M.set(key, real_value, coded_value)
        dict.__setitem__(self, key, M)

    def __setitem__(self, key, value):
        """Dictionary style assignment."""
        if isinstance(value, Morsel):
            # allow assignment of constructed Morsels (e.g. for pickling)
            dict.__setitem__(self, key, value)
        else:
            rval, cval = self.value_encode(value)
            self.__set(key, rval, cval)

    def output(self, attrs=None, header="Set-Cookie:", sep="\015\012"):
        """Return a string suitable for HTTP."""
        result = []
        items = sorted(self.items())
        for key, value in items:
            result.append(value.output(attrs, header))
        return sep.join(result)

    __str__ = output

    def __repr__(self):
        l = []
        items = sorted(self.items())
        for key, value in items:
            l.append('%s=%s' % (key, repr(value.value)))
        return '<%s: %s>' % (self.__class__.__name__, _spacejoin(l))

    def js_output(self, attrs=None):
        """Return a string suitable for JavaScript."""
        result = []
        items = sorted(self.items())
        for key, value in items:
            result.append(value.js_output(attrs))
        return _nulljoin(result)

    def load(self, rawdata):
        """Load cookies from a string (presumably HTTP_COOKIE) or
        from a dictionary.  Loading cookies from a dictionary 'd'
        is equivalent to calling:
            map(Cookie.__setitem__, d.keys(), d.values())
        """
        if isinstance(rawdata, str):
            self.__parse_string(rawdata)
        else:
            # self.update() wouldn't call our custom __setitem__
            for key, value in rawdata.items():
                self[key] = value
        return

    def __parse_string(self, str, patt=_CookiePattern):
        i = 0                 # Our starting point
        n = len(str)          # Length of string
        parsed_items = []     # Parsed (type, key, value) triples
        morsel_seen = False   # A key=value pair was previously encountered

        TYPE_ATTRIBUTE = 1
        TYPE_KEYVALUE = 2

        # We first parse the whole cookie string and reject it if it's
        # syntactically invalid (this helps avoid some classes of injection
        # attacks).
        while 0 <= i < n:
            # Start looking for a cookie
            match = patt.match(str, i)
            if not match:
                # No more cookies
                break

            key, value = match.group("key"), match.group("val")
            i = match.end(0)

            if key[0] == "$":
                if not morsel_seen:
                    # We ignore attributes which pertain to the cookie
                    # mechanism as a whole, such as "$Version".
                    # See RFC 2965. (Does anyone care?)
                    continue
                parsed_items.append((TYPE_ATTRIBUTE, key[1:], value))
            elif key.lower() in Morsel._reserved:
                if not morsel_seen:
                    # Invalid cookie string
                    return
                if value is None:
                    if key.lower() in Morsel._flags:
                        parsed_items.append((TYPE_ATTRIBUTE, key, True))
                    else:
                        # Invalid cookie string
                        return
                else:
                    parsed_items.append((TYPE_ATTRIBUTE, key, _unquote(value)))
            elif value is not None:
                parsed_items.append((TYPE_KEYVALUE, key, self.value_decode(value)))
                morsel_seen = True
            else:
                # Invalid cookie string
                return

        # The cookie string is valid, apply it.
        M = None         # current morsel
        for tp, key, value in parsed_items:
            if tp == TYPE_ATTRIBUTE:
                assert M is not None
                M[key] = value
            else:
                assert tp == TYPE_KEYVALUE
                rval, cval = value
                self.__set(key, rval, cval)
                M = self[key]


class SimpleCookie(BaseCookie):
    """
    SimpleCookie supports strings as cookie values.  When setting
    the value using the dictionary assignment notation, SimpleCookie
    calls the builtin str() to convert the value to a string.  Values
    received from HTTP are kept as strings.
    """
    def value_decode(self, val):
        return _unquote(val), val

    def value_encode(self, val):
        strval = str(val)
        return strval, _quote(strval)

My Alexa Media Player integration is now initializing first time, every time!

Yeah please re-open this issue. It’s not a 1 time occurrence anymore and is every restart.

But now it’s happening on every restart ever since the upgrade. That FAQ entry only mentions “on upgrade”. Implying the first time. Not every time.

I’ve managed to submit a clean MR to alexapy to finally fix/address this issue.

The code change is in the first 60 lines (up to class AlexaLogin:) /usr/local/lib/python3.12/site-packages/alexapy/alexalogin.py

"""Python Package for controlling Alexa devices (echo dot, etc) programmatically.

SPDX-License-Identifier: Apache-2.0

Login class.

This file could not have been written without referencing MIT code from https://github.com/Apollon77/alexa-remote.

For more details about this api, please refer to the documentation at
https://gitlab.com/keatontaylor/alexapy
"""

import asyncio
import base64
from binascii import Error
import datetime
import hashlib
from http.cookies import Morsel, SimpleCookie
from json import JSONDecodeError, dumps
import logging
import os
import pickle
import re
import secrets
from typing import Any, Callable, Optional, Union
from urllib.parse import urlencode, urlparse
from uuid import uuid4

import aiofiles
from aiofiles import os as aioos
import aiohttp
from aiohttp.client_exceptions import ContentTypeError
from bs4 import BeautifulSoup
import pyotp
from simplejson import JSONDecodeError as SimpleJSONDecodeError
from yarl import URL

from .const import APP_NAME, CALL_VERSION, EXCEPTION_TEMPLATE, LOCALE_KEY, USER_AGENT
from .errors import AlexapyPyotpInvalidKey
from .helpers import (
    _catch_all_exceptions,
    delete_cookie,
    hide_email,
    hide_serial,
    obfuscate,
)

_LOGGER = logging.getLogger(__name__)

"""Ensure cookies.Morsel contains "partitioned"
   See: https://github.com/python/cpython/issues/112713
"""
partitioned = { "partitioned" : "Partitioned" }
Morsel._reserved.update(partitioned)
Morsel._flags.add("partitioned")
_LOGGER.debug("http.cookies patch: Morsel._reserved: %s; Morsel._flags: %s", partitioned, Morsel._flags)


class AlexaLogin:

Basically, change: from http.cookies import SimpleCookie to from http.cookies import Morsel, SimpleCookie and add this new code:

"""Ensure cookies.Morsel contains "partitioned"
   See: https://github.com/python/cpython/issues/112713
"""
partitioned = { "partitioned" : "Partitioned" }
Morsel._reserved.update(partitioned)
Morsel._flags.add("partitioned")
_LOGGER.debug("http.cookies patch: Morsel._reserved: %s; Morsel._flags: %s", partitioned, Morsel._flags)

@danielbrunt57 - Works like a champ. VERY MUCH appreciated. Once again, I went to battle with this integration for several hours today and this “fix” worked right outta the gate.

I’m getting REALLY tired of the constant and ongoing problems with this integration. Alexa has to be in at least half of the HA instillations (the other half Googles Assistant). Why isn’t such an important integration handled by the core team?

PS: you might mention that after adding the custom repository, you need to download the patch integration.

It all started with the partitioned cookie issue which led me delve deeply insure AMP and alexapy and has been a steep ongoing learning curve for me. Then I tacked a feature request to be able to reconfigure all options where I had a lot more learning to do and I made mistakes, etc. Then HA 2024.8.0b0 arrived and apparently revamped aiohttp which introduced more problems which are still trying to be figured out. Someone else is working on a new AMP integration but it’s still months away and might not have much more if anything than just Media Payer functionality. So it’s all been a complicated mix of things all occuring more or less at the same time. In the beginning, AMP lacked a lot of what it’s grown into over the years and when that sort of morphing occurs, code can become complex and confusing. Plus Amazon constantly evolving and changing tends to make matters even worse…

You seem miss my points. You need to mobilize some enphathy and try to put yourself in the minds of users that are not Python programmers.

It is an unacceptable hack having to penetrate the HA docker container, patch code and then see it all reverted each time you install a HA patch release which will happen probably 10-12 times before it includes a new Python version. No user can be satisfied with that as an acceptable work around.

The automation work around is acceptable. But you need to know it. You need to be able to find it. And very few will find it if it is hidden as a closed bug. People should not expect having to find information about workarounds about a bug that is still present showing its ugly face for most, probably all users. Why is it important to close the bug? Do you pay money to Github for every open bug? What good does it do to anyone?

I have personally installed 5 Raspberry Pi Zero 2W with Jabra speakers and use these for my house TTS announcements. I expect this integration will die within a few months. Sad. It has worked well for years.

This is a WooHoo! moment for me…

image image

I gave up on the partitioned cookie issue and re-replaced cookies.py with the new 3.13 PR version, which I will have to do every week until HA upgrades to it, and returned to coding the enhanced options input.

The hack of files inside the HA container is a bit risky business. Hacking a custom component I dare. Adding the websocket dependency does not fix it. I am not strong enough in understand docker to attempt hacking code inside HA

I do not understand several things.

What does your experiences with your browser have to do with Home Assistant running in a Linux on a server? Why would the browser used to restart HA make the Python code run differently? I restart my HA from Safari browser on an iPad normally.

And why does the same Python code on the server fail when HA starts up, but works just fine when the integration is reloaded. They key to finding the root cause must and a fix. What is it in HA that is not ready when the integration attempts to start?

@danielbrunt57

I performed your procedure for replacing phyton 3.12 with version 3.13 and I also modified the manifest file as explained here but an AMP re-authentication request was presented again. Am I doing something wrong?

AMP 4.13.1 now requires alexapy==1.29.2 which fixes the error http.cookies.CookieError: Invalid attribute 'partitioned' The cookies.py patch is no longer required. If you are having other issues after updating, please do not post them here! Thanks!

Hello everyone, I decided to update HA from 2024.7.4 (where AMP was still working) to HA 2024.9.1. I removed AMP and its integration. After reinstalling the custom integration of AMP from HACS I can no longer install AMP. During the procedure it takes me back to the login site but nothing happens, just a continuous loop of email and password requests without being able to connect. I ask you to help me because I don’t know what to do anymore.

I also tried to follow some suggestions from @danielbrunt57 but to no avail. I modified the manifest file but nothing. I don’t know what to do anymore and I find it very difficult to follow this topic because I’m not very practical with programming. Screenshot 2024-09-16 alle 13 17 12 Screenshot 2024-09-16 alle 13 17 38 Screenshot 2024-09-16 alle 13 19 16

I think I’m going to avoid updating anything for a while. Home automation is great until it stops automating. And then your entire family suffers.

again, thanks for your heroic efforts. there hasn’t even been a peep from the actual authors of AMP…

@danielbrunt57 - Works like a champ. VERY MUCH appreciated. Once again, I went to battle with this integration for several hours today and this “fix” worked right outta the gate.

I’m getting REALLY tired of the constant and ongoing problems with this integration. Alexa has to be in at least half of the HA instillations (the other half Googles Assistant). Why isn’t such an important integration handled by the core team?

PS: you might mention that after adding the custom repository, you need to download the patch integration.

As I think I stated before, Python 3.13 is not scheduled to be out of beta until October and it may be a month or more before HA updates to 3.13. The PR for partitioned cookie support appears to still be on track as a Feature for 3.13, but we might see a new AMP integration before all that happens as this one is now on life support.

An update from Alan just came across 4.10.3. It’s a fix for “warning for async_forward_entry_setup”. I just tried it and restarted a few time and Alexa Media Player is still not loading on restart. Hopefully he will address it soon.

Yes, I made that fix and that change wasn’t going to fix this issue. It was to fix a different issue.

Came across this earlier today. Looks like AMP won’t be updated for a while or if ever.

https://community.home-assistant.io/t/alexa-media-player-custom-integration-on-life-support-help-wanted/725684

Alan is still publishing fixes provided by other developers. So this integration is in maintenance mode. Myself and a few others have been pushing various minor fixes to the integration. He is not actively developing this integration or providing fixes authored by him.

I just installed HA 2024.6.4 and rebooted, but the problem seems to persist.

Try inside the .storage folder.

On Fri, 21 Jun 2024, 15:09 carvan, @.***> wrote:

I am on 20024.6.3 and after removing the pickle file and re-adding the integration, I dont see the issue after any number of restarts. Very odd as it seems random for everyone.

and I’m still unable to find that file. I looked into the custom_components folder but never found it

— Reply to this email directly, view it on GitHub https://github.com/alandtse/alexa_media_player/issues/2288#issuecomment-2182829750, or unsubscribe https://github.com/notifications/unsubscribe-auth/ADIEYDAIWF4RQFCWDC4M5ELZIQXZ3AVCNFSM6AAAAABJN7M7RKVHI2DSMVQWIX3LMV43OSLTON2WKQ3PNVWWK3TUHMZDCOBSHAZDSNZVGA . You are receiving this because you are subscribed to this thread.Message ID: @.***>

Good evening, I installed a clean version of Home Assistant on another PC (intel nuc) and started the installation procedure of Alexa media player but I encountered the same problem that is the procedure brings me back to the login site but nothing happens, just a continuous cycle of email and password requests without being able to connect. Do you have any solution?

So am I interpreting this correctly, if an RP is submitted now, we get the fix via the official release and no longer have to use workarounds here?

If this is the case, I would like to save myself the manual work. What happens if I install it like this? Is it then consistent? Or will it be overwritten with the next (fixed) update?

Sorry if I’m perhaps asking stupid questions, but I haven’t yet delved that deeply into the architecture of HA, as I’m actually only a user and not a developer 😉

@danielbrunt57 are you planning to bump alexapy too with your other PRs? That should close this issue. I’m holding off on the next release since I thought that was forecoming.

@danielbrunt57 I’m not familiar with any manifest file. Where is that located and why does it need to be modified? I thought HACS handled updates for us.

custom_components/alexa_media folder

cookies.py is an easy fix in docker, copy the updated cookies.py locally and mount the updated file readonly into the container:

services:

  homeassistant:
    image: homeassistant/home-assistant:latest
    container_name: homeassistant
    restart: always

    volumes:
      - ./homeassistant:/config
      - homeassistant_pgsocket:/var/run/postgresql    
      - /etc/timezone:/etc/timezone:ro
      - /etc/localtime:/etc/localtime:ro

      #alexa integration fix 
      #https://github.com/alandtse/alexa_media_player/issues/2288
      - ./alexa_fix/cookies.py:/usr/local/lib/python3.12/http/cookies.py:ro

PS: you might mention that after adding the custom repository, you need to download the patch integration.

Thanks for the workaround. It works for me too. You should also mention downloading the HACS package. I was wondering if something was missing.

I’ve edited my post above, thanks!

Thanks for the workaround. It works for me too. You should also mention downloading the HACS package. I was wondering if something was missing.

You’re right, I overlooked that minor but important detail.

For me to understand: Is it somehow foreseeable when the error will finally be fixed? I don’t quite understand the error and, above all, why a patch is now needed to enable stable functionality. I’ve never come across this since I startd using HA.

Many thanks for your work!!!

Partitioned cookies are rather new in the browser/website realm (google CHIPS). The cookies.py I found is from a pull request for Python 3.13 beta to support partitioned cookies. There was lots of back and forth on the subject in the python community since Dec/Jan but it’s looking like the PR will likely be merged. We won’t see it in HA until 3.13 final comes out and even then HA core will have to do their tests with it before switching HA to Python 3.13. They might already be doing that with the 3.13 beta but I’m only guessing…

I was using the automation from the beginning to fix the problem but today I have noticed that it fixes the issue no more.

Well after a day it stopped working. Don’t know why. The change I made is still in the file. I guess I will go back to using my automation to do the reload.

use Advanced SSH & Web Terminal with enabled Safe Mode then

docker exec -it $(docker ps -f name=homeassistant -q) bash
vi /usr/local/lib/python3.12/site-packages/alexapy/alexalogin.py

I was already using the original cookies.py file so I just made the changes to alexalogin.py. Then restarted it 3 times and it started each time on its own. Thanks @danielbrunt57 !

Ill try. Wait…

my workaround:

alias: xSYSTEM - Reload Alexa Media Player after HA starts description: Workaround trigger:

platform: homeassistant event: start condition: [] action: delay: hours: 0 minutes: 1 seconds: 0 milliseconds: 0 alias: Reload Alexa Media Player integration service: homeassistant.reload_config_entry data: {} enabled: true target: entity_id: media_player.toilet_echo mode: single


#reload of one device is enough ;-)

That solution has already been posted! Also, please format your posts correctly by surrounding your code with triple back quotes before and after the code on their own line. Or select the code segment and use the editor’s <> button to encase the block with triple backquotes.

alias: Home Assistant Startup
description: ""
trigger:
  - platform: homeassistant
    event: start
condition: []
action:

AMP doesn’t even initialize me. I already put the error above

After getting 2024.7.0 on Wednesday and also upgrading to the latest AMP, no the issue persists. I just now decided to retry core-2024.7.0 with a different test:

  • Removed the integration
  • Restored the original cookies.py file in /usr/local/lib/homeassistant/homeassistant/python3.12
  • Removed /config/.storage/alexa*
  • Restarted HA
  • Installed the integration
  • Restarted HA -> AMP failed to initialize <
  • Edited /config/custom_components/alexa_media/manifest.json and added “HACS” to dependencies
  • Restarted HA
  • *** AMP initialized ***
  • Restarted HA a second time -> AMP failed to initialize <
  • Tried “ping” instead of “hacs” -> AMP failed to initialize <
  • Tried “websocket” -> AMP not found!!! <
  • Reverted to modifying ha startup automation and reloading integration at different points and I finally arrived at this which worked and AMP finally loads and I get my verbal message on Office Echo Dot Left

image image

Note: I added "hacs" dependency to manifest.json otherwise AMP would be in the 1st initializing state for a v e r y long time.

Using the original python3.12 cookies.py file without partitioned cookie support, this worked for me but it does delay my complete startup by a lot. I will probably go back to the python3.13 file…

@danielbrunt57 Sorry I didn’t check for partitioned cookie error before I rolled back. I just tried again and restarted 6 times but have not gotten the error yet. Alexa Media player is still loading as it should. If I do get it later, I will check for error.

@danielbrunt57 thank you for your suggestion. I confirm that following the above (https://github.com/alandtse/alexa_media_player/issues/2288#issuecomment-2181877003 )recommendation fixed my problem

I deleted the Alexa Media Player integration in HA 2024.6.4, deleted the custom component in HACS and restarted HA. I then deleted the following files in /config/.storage: -rw-r–r-- 1 root root 98 Jun 9 00:39 alexa -rw-r–r-- 1 root root 783 Jun 26 16:13 alexa_auth -rw-r–r-- 1 root root 2577 Jun 26 16:44 alexa_media.daniel@brunt.ca.pickle

I re-installed Alexa Media Player Custom Component in HACS, restarted HA and re-installed the Alexa Media Player integration and, after three HA restarts, Alexa Media Player is initializing just fine now.

It might be worth noting that before starting the above exercise, I reviewed my settings in Edge browser and in Privacy, search and services where I had changed Balanced to Basic some number of weeks ago, I changed it back to Balanced.

So for me, this is no longer an issue.

For me, renaming the .pickle file and deleting the integration worked as this forced a re-authentication when adding the integration back in. Have not restarted since doing that so unsure if it’s persistent.

Mine does’t work even after reloading it. HA 2024.6.3