`NotRequired` and `Required` not properly handled with Python < 3.11 in `TypedDict` conversion about robotframework HOT 6 CLOSED

from robot.api.deco import keyword
from signals import WriteSignal

@keyword(name="Write")
def write(self, *signals: WriteSignal) -> None:
    print("test")
    # self.test_library.publish_can_message("write", signals)

*** Settings ***
Metadata         Version                                                                                                  0.1
Documentation    Simple example showcasing NotRequired error:

Force Tags       PreCheck

Library                          ${EXECDIR}/keywords.py

*** Keywords ***

WriteValue
    [Documentation]                 Create dictionary and publishes CAN:Write message
    ...                             with signal values
    [Arguments]                     ${signal}                                                    ${value}                                  ${interval}=${None}
    &{DICT} =                       Create Dictionary                                            Network=CAN5                              Signal=${signal}                           Value=${value}
    Run Keyword If                  $interval is not None                                        Set To Dictionary                         ${CAN_DICT}                                Interval=${interval}
    keywords.Write                  ${DICT}

*** Test Cases ***

Change Language from Radio to a Language supported by IHU (French)
    WriteValue              1   1
    Sleep                      2

from typing import Any, Literal, Protocol, Union
from typing_extensions import NotRequired, TypedDict

class Signal(TypedDict):
    """Base Signal"""

    Network: str
    Signal: str


class ReadSignal(Signal):
    """Read Signal"""

    Mode: Literal["Once", "OnChange"]
    Interval: NotRequired[Union[int, None]]


class WriteSignal(Signal):
    """Write Signal"""

    Value: str
    Interval: NotRequired[Union[int, None]]


class GeneralLogger(Protocol):  # pylint: disable=too-few-public-methods
    """Definition of logger, which might be used as async in MessageSubscriber"""

    def log(self, level: int, msg: object, *args: Any, **kwargs: Any) -> None:  # type: ignore[misc]
        """Log message with provided level"""

hints: {'x': <class 'int'>, 'y': typing_extensions.NotRequired[int]}
required: frozenset({'x', 'y'})

hints: {'x': <class 'int'>, 'y': <class 'int'>}
required: frozenset({'x'})