
    i9              	       
   d dl Z d dlZd dlZd dlZd dlZd dlmZmZ ddlm	Z	 ddl
mZmZmZmZmZmZ ddeeeej&                  f   dee   fdZd	eeeej&                  f   defd
Zdedeeeeeef   fdZddZddZd ZdZy)    N)UnionList   )ecodes)
InputEventevent_factoryKeyEventRelEventAbsEventSynEventinput_device_dirreturnc                 |    t        j                   dj                  |             }t        t        t        |            S )z8List readable character devices in ``input_device_dir``.z	{}/event*)globformatlistfilter	is_device)r   fnss     T/home/obispo/Crisostomo_bridge/mision_env/lib/python3.12/site-packages/evdev/util.pylist_devicesr      s0     ))K&&'78
9Cy#&''    fnc                 (   t         j                  j                  |       syt        j                  |       t        j                     }t        j
                  |      syt        j                  | t         j                  t         j                  z        syy)z<Check if ``fn`` is a readable and writable character device.FT)	ospathexistsstatST_MODES_ISCHRaccessR_OKW_OK)r   ms     r   r   r      s\     77>>"
DLL!A<<?99R277*+r   eventc                 Z    | j                   t        v rt        | j                      |       S | S )a  
    Categorize an event according to its type.

    The :data:`event_factory <evdev.events.event_factory>` dictionary
    maps event types to sub-classes of :class:`InputEvent
    <evdev.events.InputEvent>`. If the event cannot be categorized, it
    is returned unmodified.)typer   )r%   s    r   
categorizer(   #   s)     zz]"UZZ(//r   c              #     K   | j                         D ]s  \  }}t        j                  |   }|t        j                  k(  rt        j                  }n"t        t        |j                  d      d         }t        |||      }||f|f u yw)a  
    Resolve event codes and types to their verbose names.

    :param typecodemap: mapping of event types to lists of event codes.
    :param unknown: symbol to which unknown types or codes will be resolved.

    Example
    -------
    >>> resolve_ecodes_dict({ 1: [272, 273, 274] })
    { ('EV_KEY', 1): [('BTN_MOUSE',  272),
                      ('BTN_RIGHT',  273),
                      ('BTN_MIDDLE', 274)] }

    If ``typecodemap`` contains absolute axis info (instances of
    :class:`AbsInfo <evdev.device.AbsInfo>` ) the result would look
    like:

    >>> resolve_ecodes_dict({ 3: [(0, AbsInfo(...))] })
    { ('EV_ABS', 3L): [(('ABS_X', 0L), AbsInfo(...))] }
    _N)itemsr   EVEV_KEYkeysgetattrsplitresolve_ecodes)typecodemapunknownetypecodes	type_name
ecode_dictresolveds          r   resolve_ecodes_dictr:   2   s     , $))+ 
+uIIe$	 FMM!J )=b)ABJ!*eW=% (**
+s   BB
c                     g }|D ]Z  }t        |t              r'|d   | v r| |d      |d   f|d   f}n||d   f|d   f}n|| v r| |   |f}n||f}|j                  |       \ |S )z
    Resolve event codes and types to their verbose names.

    Example
    -------
    >>> resolve_ecodes(ecodes.BTN, [272, 273, 274])
    [(['BTN_LEFT', 'BTN_MOUSE'], 272), ('BTN_RIGHT', 273), ('BTN_MIDDLE', 274)]
    r   r   )
isinstancetupleappend)r8   
ecode_listr4   resecodels         r   r2   r2   U   s     C eU#Qx:% q*E!H5uQx@uQx(%(3 
"&.e$

1  Jr   c                 v   t        j                  |       } t        j                  t              }t
        j                  j                         D ]`  \  }}|j                         D ]H  \  }}t        |t              r|fn|}|D ])  }| j                  |      s||   j                  |        H J b t        |      S )a  
    Find ecodes matching a regex and return a mapping of event type to event codes.

    regex can be a pattern string or a compiled regular expression object.

    Example
    -------
    >>> find_ecodes_by_regex(r'(ABS|KEY)_BR(AKE|EAK)')
    {1: [411], 3: [10]}
    >>> res = find_ecodes_by_regex(r'(ABS|KEY)_BR(AKE|EAK)')
    >>> resolve_ecodes_dict(res)
    {
        ('EV_KEY', 1): [('KEY_BREAK', 411)],
        ('EV_ABS', 3): [('ABS_BRAKE', 10)]
    }
    )recompilecollectionsdefaultdictr   r   bytyper,   r<   strmatchr>   dict)regexresult	type_coder6   codenamesnames          r   find_ecodes_by_regexrR   r   s    $ JJuE$$T*F"MM//1 	5 ;;= 	KD% *5# 6UHEE ;;t$9%,,T2	 <r   )r   r   r(   r2   r:   rR   )z
/dev/input)?)rF   r   r   rD   r   typingr   r    r   eventsr   r   r	   r
   r   r   rI   bytesPathLiker   boolr   r(   r:   r2   rR   __all__ r   r   <module>r\      s      	 	    U U(5eR[[)@#A (UYZ]U^ (%UBKK/0 T  j U:x8U]+]%^  +F:@ wr   