app_model.types #

@classmethod
def from_int(cls, key_int: int, os: OperatingSystem | None = None) -> "KeyBinding":
    """Create a KeyBinding from an integer."""
    # a multi keybinding is represented as an integer
    # with the first_part in the lowest 16 bits,
    # the second_part in the next 16 bits, etc.
    first_part = key_int & 0x0000FFFF
    chord_part = (key_int & 0xFFFF0000) >> 16
    if chord_part != 0:
        return cls(
            parts=[
                SimpleKeyBinding.from_int(first_part, os),
                SimpleKeyBinding.from_int(chord_part, os),
            ]
        )
    return cls(parts=[SimpleKeyBinding.from_int(first_part, os)])

@classmethod
def from_str(cls, key_str: str) -> "KeyBinding":
    """Parse a string into a SimpleKeyBinding."""
    parts = [SimpleKeyBinding.from_str(part) for part in key_str.split()]
    return cls(parts=parts)

def to_int(self, os: OperatingSystem | None = None) -> int:
    """Convert this KeyBinding to an integer representation."""
    if len(self.parts) > 2:  # pragma: no cover
        raise NotImplementedError(
            "Cannot represent chords with more than 2 parts as int"
        )
    os = OperatingSystem.current() if os is None else os
    parts = [part.to_int(os) for part in self.parts]
    if len(parts) == 2:
        return KeyChord(*parts)
    return parts[0]

def to_text(
    self,
    os: OperatingSystem | None = None,
    use_symbols: bool = False,
    joinchar: str = "+",
) -> str:
    """Get a text representation of this KeyBinding.

    Optionally, the string representation can be constructed with symbols
    like ↵ for Enter or OS specific ones like ⌘ for Meta on MacOS. If no symbols
    should be used, the string representation will use the OS specific names
    for the keys like `Cmd` for Meta or `Option` for Ctrl on MacOS.

    Also, a join character can be defined. By default `+` is used.
    """
    return " ".join(
        part.to_text(os=os, use_symbols=use_symbols, joinchar=joinchar)
        for part in self.parts
    )

@classmethod
def validate(cls, v: Any) -> "KeyBinding":
    """Validate a SimpleKeyBinding."""
    if isinstance(v, KeyBinding):
        return v
    if isinstance(v, SimpleKeyBinding):
        return cls(parts=[v])
    if isinstance(v, int):
        return cls.from_int(v)
    if isinstance(v, str):
        return cls.from_str(v)
    raise TypeError("invalid keybinding")  # pragma: no cover

@classmethod
def from_event_code(cls, event_code: int) -> 'KeyCode':
    """Return the `KeyCode` associated with the given event code.

    Returns `KeyCode.UNKNOWN` if no `KeyCode` is associated with the event code.
    """
    return _EVENTCODE_TO_KEYCODE.get(event_code, KeyCode.UNKNOWN)

@classmethod
def from_string(cls, string: str) -> 'KeyCode':
    """Return the `KeyCode` associated with the given string.

    Returns `KeyCode.UNKNOWN` if no `KeyCode` is associated with the string.
    """
    return keycode_from_string(string)

def os_name(self, os: Optional[OperatingSystem] = None) -> str:
    """Get a string representation of this `KeyCode` using the OS specific naming for the key.

    This differs from `__str__` since with it a normalized representation (constant to all OSes) is given.
    Sometimes these representations coincide but not always! Some examples:
        * `KeyCode.Enter` is represented by `Enter` (`__str__` represents it as `Enter`)
        * `KeyCode.Meta` is represented by `Win` on Windows, `Super` on Linux and `Cmd` on MacOS
        (`__str__` represents it as `Meta`)

    If no OS is given, the current detected one is used.
    """
    os = OperatingSystem.current() if os is None else os
    return keycode_to_os_name(self, os)

def os_symbol(self, os: Optional[OperatingSystem] = None) -> str:
    """Get a string representation of this `KeyCode` using a symbol/OS specific symbol.

    Some examples:
        * `KeyCode.Enter` is represented by `↵`
        * `KeyCode.Meta` is represented by `⊞` on Windows, `Super` on Linux and `⌘` on MacOS

    If no OS is given, the current detected one is used.
    """
    os = OperatingSystem.current() if os is None else os
    return keycode_to_os_symbol(self, os)

@staticmethod
def current() -> "OperatingSystem":
    """Return the current operating system as enum."""
    return _CURRENT

@classmethod
def from_string(cls, string: str) -> 'ScanCode':
    """Return the KeyCode associated with the given string.

    Returns ScanCode.UNIDENTIFIED if no match is found.
    """
    return scancode_from_string(string)

@classmethod
def from_int(
    cls, key_int: int, os: OperatingSystem | None = None
) -> "SimpleKeyBinding":
    """Create a SimpleKeyBinding from an integer."""
    ctrl_cmd = bool(key_int & KeyMod.CtrlCmd)
    win_ctrl = bool(key_int & KeyMod.WinCtrl)
    shift = bool(key_int & KeyMod.Shift)
    alt = bool(key_int & KeyMod.Alt)

    os = OperatingSystem.current() if os is None else os
    ctrl = win_ctrl if os.is_mac else ctrl_cmd
    meta = ctrl_cmd if os.is_mac else win_ctrl
    key = key_int & 0x000000FF  # keycode mask

    return cls(ctrl=ctrl, shift=shift, alt=alt, meta=meta, key=key)

@classmethod
def from_str(cls, key_str: str) -> "SimpleKeyBinding":
    """Parse a string into a SimpleKeyBinding."""
    mods, remainder = _parse_modifiers(key_str.strip())
    key = KeyCode.from_string(remainder)
    return cls(**mods, key=key)

def is_modifier_key(self) -> bool:
    """Return true if this is a modifier key."""
    return self.key in (
        KeyCode.Alt,
        KeyCode.Shift,
        KeyCode.Ctrl,
        KeyCode.Meta,
        KeyCode.UNKNOWN,
    )

def to_int(self, os: OperatingSystem | None = None) -> int:
    """Convert this SimpleKeyBinding to an integer representation."""
    os = OperatingSystem.current() if os is None else os
    mods: KeyMod = KeyMod.NONE
    if self.ctrl:
        mods |= KeyMod.WinCtrl if os.is_mac else KeyMod.CtrlCmd
    if self.shift:
        mods |= KeyMod.Shift
    if self.alt:
        mods |= KeyMod.Alt
    if self.meta:
        mods |= KeyMod.CtrlCmd if os.is_mac else KeyMod.WinCtrl
    return mods | (self.key or 0)

def to_text(
    self,
    os: OperatingSystem | None = None,
    use_symbols: bool = False,
    joinchar: str = "+",
) -> str:
    """Get a user-facing string representation of this SimpleKeyBinding.

    Optionally, the string representation can be constructed with symbols
    like ↵ for Enter or OS specific ones like ⌘ for Meta on MacOS. If no symbols
    should be used, the string representation will use the OS specific names
    for the keys like `Cmd` for Meta or `Option` for Ctrl on MacOS.

    Also, a join character can be defined. By default `+` is used.
    """
    os = OperatingSystem.current() if os is None else os
    keybinding_elements = [*self._mods2keycodes()]
    if self.key:
        keybinding_elements.append(self.key)

    return joinchar.join(
        kbe.os_symbol(os=os) if use_symbols else kbe.os_name(os=os)
        for kbe in keybinding_elements
    )

def to_keybinding_rule(self) -> "KeyBindingRule":
    """Return KeyBindingRule for this StandardKeyBinding."""
    from .._keybinding_rule import KeyBindingRule

    return KeyBindingRule(**_STANDARD_KEY_MAP[self])