Why does the literal string """"""" (seven quotes) give an error?

Processing clients input we often use the strip() method. If we wanna remove starting-ending symbols from some specific set we just place all it in the parameter.
The code

".yes' ".strip(". '")

obviously gives 'yes' string as a result.
When I try to remove set ' ". The result depends from this symbols order. Variant ".yes' ".strip(""" ."'""") works properly, when variant with symbol " at the end gives the SyntaxError: unterminated string literal (detected at line 1).

So the question is: "why literal string """"""" (using seven quotes) gives error? It is just the same '"'!"

Updated 1. They say I have wrong mental model of literals. SO lets look documentation:

Triple quoted: '''Three single quotes''', """Three double quotes"""

And . Click here to verify. So

1. longstring i.e. """longstringitem"""
2. longstringitem may be a single char.

So do we have to rewrite documentation or interpreter?

Updated 2. I propose to rewrite the logic of the interpreter. Because my example starts from """ and ends with """ and have one symbol inside. It differs from ''' bc pairs '' have to use the same symbol ' between. I am not using """ inside """ """ pair. See you the difference?

Updated 3. I've register my question on Python documentation issue. Can see here.

Updated 4. I've marked the answer as the answer because I promise to do it )). But text from docs really says:
This is wrong: '''
This is wrong: """
This is wrong: """""""""

And I am agree. But no place in documentation that says:
""""""" is wrong. Thats all that I wanna to say.

No formal rules about it.

Updated 5. Look

In[5] :""""TEXT" """
Out[5]: '"TEXT" '

In[6] :""""TEXT""""
  File "C:\Users\vasil\AppData\Local\Temp\ipykernel_551695884511.py", line 1
    """"TEXT""""
                ^
SyntaxError: EOL while scanning string literal

I.e. 4 in row """" is alowed on start and prohibited at the end. Is it correct situation?

This reflects the documented behaviour as per the Python language spec around lexical analysis of strings:

> In triple-quoted literals, unescaped newlines and quotes are allowed (and are retained), except that three unescaped quotes in a row terminate the literal. (A “quote” is the character used to open the literal, i.e. either ' or ".)

The crucial point here is that "three unescaped quotes in a row terminate the literal". So if you begin a literal with """, that literal ends as soon as another """ sequence is encountered: the parser doesn't look ahead of that to try to infer a different endpoint for the literal.

When the parser encounters """"""" (a run of seven double-quotes), therefore:

1. The 1st, 2nd and 3rd characters tell the parser it's dealing with a literal delimited by triple double-quotes.
2. The 4th, 5th and 6th characters constitute those "three unescaped quotes" so they terminate the literal.
3. The 7th character is then " with no following " that it can be paired with, so that 7th character constitutes an unterminated literal. The parser fails with SyntaxError: unterminated string literal.

It's worth mentioning that backslash-escaping can still be used to prevent the quote character being treated as a quote. For example:

s = """\""""
print(s)

prints:

"

This behaviour is determined with one interestin thing in python parser. You can read it here.

At line near 114 you see:

# Tail end of """ string.
Double3 = r'[^"\\]*(?:(?:\\.|"(?!""))[^"\\]*)*"""'

This part of the code define regular expression for the tale of triple quated literal. We can see that separate " is alowed BUT if it does not followed with another ". So logicaly it alowed but this regular expression prohibit it.

This is the correct answer for my question. But who cares....