
    }tf=                    \   d Z ddlmZ ddlZ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 ddlmZmZmZmZ ddlmZmZ d	d
lmZ d	dlmZ d	dlmZ d	dlmZ d	Z  G d de!      Z" G d de#      Z$ G d de#      Z% e	jL                  de"        G d de#      Z' G d de      Z(y)z?
Emit structured, discrete events when various actions happen.
    )annotationsN)datetimetimezone)ValidationError)
jsonlogger)DictInstanceSetdefault)ConfigLoggingConfigurable   )
SchemaTypeSchemaRegistry)Handlers)JUPYTER_EVENTS_CORE_VALIDATORc                      e Zd ZdZy)SchemaNotRegisteredzzA warning to raise when an event is given to the logger
    but its schema has not be registered with the EventLogger
    N__name__
__module____qualname____doc__     _/var/www/html/software/conda/envs/higlass/lib/python3.12/site-packages/jupyter_events/logger.pyr   r          r   r   c                      e Zd ZdZy)ModifierErrorzRAn exception to raise when a modifier does not
    show the proper signature.
    Nr   r   r   r   r    r    #   r   r   r    c                      e Zd ZdZy)CoreMetadataErrorz:An exception raised when event core metadata is not valid.Nr   r   r   r   r"   r"   )   s    Dr   r"   oncec                      e Zd ZdZy)ListenerErrorzRAn exception to raise when a listener does not
    show the proper signature.
    Nr   r   r   r   r%   r%   2   r   r   r%   c                      e Zd ZU dZ eddd      j                  d      Z eed      Z	 e
i d	      Z e
i d
      Z e
i d      Z e       Zded<   ddZ ed      dd       Zd  fdZ	 	 d!	 	 	 	 	 	 	 d" fdZd#dZd$dZd$dZdd	 	 	 	 	 d%dZdd	 	 	 	 	 d%dZddd	 	 	 	 	 	 	 d&dZdd	 	 	 	 	 d'dZdd	 	 	 	 	 	 	 d(dZ xZS ))EventLoggera  
    An Event logger for emitting structured events.

    Event schemas must be registered with the
    EventLogger using the `register_schema` or
    `register_schema_file` methods. Every schema
    will be validated against Jupyter Event's metaschema.
    NTzA list of logging.Handler instances to send events to.

        When set to None (the default), all events are discarded.
        )default_value
allow_nonehelp)configzbThe SchemaRegistry for caching validated schemas
        and their jsonschema validators.
        )r*   z0A mapping of schemas to their list of modifiers.z9A mapping of schemas to the listeners of modified events.z?A mapping of schemas to the listeners of unmodified/raw events.zset[asyncio.Task[t.Any]]_active_listenersc                \   K   t        j                  | j                  ddi d{   S 7 w)z#Gather all of the active listeners.return_exceptionsTN)asynciogatherr,   selfs    r   gather_listenerszEventLogger.gather_listeners\   s&     ^^T%;%;TtTTTTs   #,*,schemasc                    t               S Nr   r1   s    r   _default_schemaszEventLogger._default_schemas`   s    r   c                f   t        |   |i | t        dz   t        t	        |             z   }t        j                  |      | _        d| j                  _        | j                  j                  t
        j                         | j                  r#| j                  D ]  }| j                  |        yy)zInitialize the logger..FN)super__init__r   stridlogging	getLogger_logger	propagatesetLevelINFOhandlersregister_handler)r2   argskwargslog_namehandler	__class__s        r   r;   zEventLogger.__init__d   s     	$)&) c>C4M1((2!&gll+==== /%%g./ r   c                    | j                  |      }|j                  dg       dfd}||d<   t        d|i      }t        |   |dd       y)zLoad EventLogger traits from a Config object, patching the
        handlers trait in the Config object to avoid deepcopy errors.
        rD   c                      S r6   r   )rD   s   r   get_handlersz.EventLogger._load_config.<locals>.get_handlers   s    Or   r'   N)section_namestraits)returnzlist[logging.Handler])_find_my_configpopr   r:   _load_config)	r2   cfgrN   rO   my_cfgrM   eventlogger_cfgrD   rJ   s	          @r   rS   zEventLogger._load_configv   s[     %%c**0**Z*D	 *z !-!89_DNr   c                2   | j                   j                  |      }|j                  }|| j                  vrt	               | j                  |<   || j
                  vrt	               | j
                  |<   || j                  vrt	               | j                  |<   yy)zRegister this schema with the schema registry.

        Get this registered schema using the EventLogger.schema.get() method.
        N)r4   registerr=   
_modifiersset_modified_listeners_unmodified_listeners)r2   schemaevent_schemakeys       r   register_event_schemaz!EventLogger.register_event_schema   s    
 ||,,V4oo doo%#&5DOOC d...,/ED$$S)d000.1eD&&s+ 1r   c                     d fd}t        j                  |      }|j                  |        j                  j	                  |       | j
                  vr j
                  j                  |       yy)zRegister a new logging handler to the Event Logger.

        All outgoing messages will be formatted as a JSON string.
        c                    j                   j                  | d         }d|j                  vr| d= t        j                  | fi |S )aE  Python's logger always emits the "message" field with
            the value as "null" unless it's present in the schema/data.
            Message happens to be a common field for event logs,
            so special case it here and only emit it if "message"
            is found the in the schema's property list.
            
__schema__message)r4   get
propertiesjsondumps)recordrG   r]   r2   s      r   _handle_message_fieldz;EventLogger.register_handler.<locals>._handle_message_field   sH     \\%%f\&:;F 1 119%::f///r   )json_serializerN)ri   t.AnyrG   rl   rP   r<   )r   JsonFormattersetFormatterr@   
addHandlerrD   append)r2   rI   rj   	formatters   `   r   rE   zEventLogger.register_handler   sb    
	0 ,,1
	 	Y'($--'MM  ) (r   c                    | j                   j                  |       || j                  v r| j                  j                  |       yy)z>Remove a logging handler from the logger and list of handlers.N)r@   removeHandlerrD   remove)r2   rI   s     r   remove_handlerzEventLogger.remove_handler   s7    ""7+dmm#MM  ) $r   )	schema_idc               0   t        |      sd}t        |      |rE| j                  j                  |t	                     }|j                  |       || j                  |<   y| j                  D ](  }|||k(  s| j                  |   j                  |       * y)aG  Add a modifier (callable) to a registered event.

        Parameters
        ----------
        modifier: Callable
            A callable function/method that executes when the named event occurs.
            This method enforces a string signature for modifiers:

                (schema_id: str, data: dict) -> dict:
        z`modifier` must be a callableN)callable	TypeErrorrY   re   rZ   add)r2   rv   modifiermsg	modifiersid_s         r   add_modifierzEventLogger.add_modifier   s    " !1CC.   ++Isu=IMM(#)2DOOI&?? 	3C C9$4$((2	3r   c                   |r| j                   |   j                  |       y| j                  j                  D ]>  }| j                   |   j                  |       | j                   |   j                  |       @ y)a  Remove a modifier from an event or all events.

        Parameters
        ----------
        schema_id: str
            If given, remove this modifier only for a specific event type.
        modifier: Callable[[str, dict], dict]

            The modifier to remove.
        N)rY   discardr4   
schema_ids)r2   rv   r{   s      r   remove_modifierzEventLogger.remove_modifier   sg    " OOI&..x8 "\\44 =		*228<	*228<=r   )modifiedrv   c                  t        |      sd}t        |      |r|rE| j                  j                  |t	                     }|j                  |       || j                  |<   y| j                  j                  |t	                     }|j                  |       || j                  |<   y| j                  j                  D ]I  }|||k(  s|r| j                  |   j                  |       ,| j                  |   j                  |       K y)a  Add a listener (callable) to a registered event.

        Parameters
        ----------
        modified: bool
            If True (default), listens to the data after it has been mutated/modified
            by the list of modifiers.
        schema_id: str
            $id of the schema
        listener: Callable
            A callable function/method that executes when the named event occurs.
        z`listener` must be a callableN)	rx   ry   r[   re   rZ   rz   r\   r4   r   )r2   r   rv   listenerr|   	listenersr~   s          r   add_listenerzEventLogger.add_listener   s    & !1CC.   !4488CEJ	h'6?((32266y#%HIMM(#4=D&&y1<<** 	BC C9$4,,S155h?..s377A	Br   c               0   |r=| j                   |   j                  |       | j                  |   j                  |       y| j                  j                  D ]>  }| j                   |   j                  |       | j                  |   j                  |       @ y)a   Remove a listener from an event or all events.

        Parameters
        ----------
        schema_id: str
            If given, remove this modifier only for a specific event type.

        listener: Callable[[EventLogger, str, dict], dict]
            The modifier to remove.
        N)r[   r   r\   r4   r   )r2   rv   r   s      r   remove_listenerzEventLogger.remove_listener$  s    " $$Y/77A&&y199(C "\\44 H	((3;;HE**95==hGHr   )timestamp_overridec                    j                   s j                  |   s j                  |   sy| j                  vr t	        j
                  | dt        d       y j                  j                  |      }t        j                  |      } j                  |j                     D ]  } |||      }  j                  |j                     r j                  j                  ||        j                  j                  ||       |$t        j                  t        j                         n|}|j#                         dz   ||j$                  t&        d}	 t)        j*                  |       |j1                  |        j2                  j5                  |       d fd	}
 j                  |   D ]L  }t7        j8                   | ||
            } j:                  j=                  |       |j?                  |
       N  j                  |   D ]R  }t7        j8                   | ||
            } j:                  j=                  |       d fd}
|j?                  |
       T |S # t,        $ r}	t.        |	d}	~	ww xY w)a  
        Record given event with schema has occurred.

        Parameters
        ----------
        schema_id: str
            $id of the schema
        data: dict
            The event to record
        timestamp_override: datetime, optional
            Optionally override the event timestamp. By default it is set to the current timestamp.

        Returns
        -------
        dict
            The recorded event data
        Nz has not been registered yet. If this was not intentional, please register the schema using the `register_event_schema` method.   )
stacklevel)rv   data)tzZ)__timestamp__rc   __schema_version____metadata_version__c                    | j                         }|rj                  j                  |       j                  j	                  |        y r6   	exceptionlogerrorr,   r   taskerrr2   s     r   _listener_task_donez-EventLogger.emit.<locals>._listener_task_done  s8     .."Cs#""**40r   )loggerrv   r   c                    | j                         }|rj                  j                  |       j                  j	                  |        y r6   r   r   s     r   r   z-EventLogger.emit.<locals>._listener_task_done  s8     nn&HHNN3'&&..t4r   )r   zasyncio.Task[t.Any]rP   None) rD   r[   r\   r4   warningswarnr   re   copydeepcopyrY   r=   validate_eventr   nowr   utc	isoformatversionEVENTS_METADATA_VERSIONr   validater   r"   updater@   infor/   create_taskr,   rz   add_done_callback)r2   rv   r   r   r]   modified_datar{   	timestampcapsuler   r   r   r   s   `            r   emitzEventLogger.emit?  sT   , ,,Y7..y9 DLL(MM+ 2 2 $ !!), d+		2 	NH$y}MM	N %%fii0LL''	48 	##I}= .@-GHLLHLL)M_ 	 '002S8#"(..$;	
	-)227; 	}%'"	1 00; 	8H &&'&D ""&&t, ""#67	8 229= 	8H&&xtyW['\]D""&&t,5 ""#67	8  c  	-#,	-s   I 	I3'I..I3)rP   zlist[t.Any])rP   r   )rF   rl   rG   rl   rP   r   )NN)rT   r   rN   list[str] | NonerO   r   rP   r   )r]   r   rP   r   )rI   zlogging.HandlerrP   r   )rv   
str | Noner{   z5t.Callable[[str, dict[str, t.Any]], dict[str, t.Any]]rP   r   )r   boolrv   r   r   Qt.Callable[[EventLogger, str, dict[str, t.Any]], t.Coroutine[t.Any, t.Any, None]]rP   r   )rv   r   r   r   rP   r   )rv   r<   r   zdict[str, t.Any]r   zdatetime | NonerP   zdict[str, t.Any] | None)r   r   r   r   r   tagrD   r	   r   r4   r   rY   r[   r\   r
   r,   __annotations__r3   r   r7   r;   rS   r`   rE   ru   r   r   r   r   r   __classcell__)rJ   s   @r   r'   r'   8   s     
cc  G bQRJr(cd 
R 36%/7U Y   /* +/#'	OO (O !	O
 
O,4 *4* !% 3  3 H	 3
 
 3J !%= = H	=
 
=:  $	*B *B 	*B
 d*B 
*B^ !%H H d	H
 
H8 `dss'7sM\s	 sr   r'   ))r   
__future__r   r/   r   rg   r>   typingtr   r   r   
jsonschemar   pythonjsonloggerr   	traitletsr   r	   r
   r   traitlets.configr   r   r]   r   schema_registryr   rO   r   
validatorsr   r   Warningr   	Exceptionr    r"   simplefilterr%   r'   r   r   r   <module>r      s    #       ' & ' 2 2 8  +  5  ' I E	 E   f1 2I z% zr   