
    Mh>                       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 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!  ed          Z" ee"           ed          k    rddl#m$Z$ nddl%m$Z$ d
Z& G d de'          Z( G d de)          Z* G d de)          Z+ e	j,        de(            G d de)          Z- G d de          Z.dS )z?
Emit structured, discrete events when various actions happen.
    )annotationsN)datetimetimezone)version)ValidationError)parse)DictInstanceSetdefault)ConfigLoggingConfigurable   )
SchemaTypeSchemaRegistry)Handlers)JUPYTER_EVENTS_CORE_VALIDATORzpython-json-loggerz3.1.0)JsonFormatterc                      e Zd ZdZdS )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__     U/var/www/html/test/jupyter/venv/lib/python3.11/site-packages/jupyter_events/logger.pyr   r   %              r   r   c                      e Zd ZdZdS )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dS )CoreMetadataErrorz:An exception raised when event core metadata is not valid.Nr   r   r   r   r$   r$   1   s        DDDDr   r$   oncec                      e Zd ZdZdS )ListenerErrorzRAn exception to raise when a listener does not
    show the proper signature.
    Nr   r   r   r   r'   r'   :   r    r   r'   c                      e Zd ZU dZ eddd                              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dAd!ZdBd$ZdBd%Zdd&dCd+Zdd&dCd,Zddd-dDd2Zdd&dEd3Zdd4dFd;Z xZS )G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_listenersreturnlist[t.Any]c                >   K   t          j        | j        ddi d{V S )z#Gather all of the active listeners.return_exceptionsTN)asynciogatherr.   selfs    r   gather_listenerszEventLogger.gather_listenersd   s0      ^T%;TtTTTTTTTTTr   schemasr   c                    t                      S Nr   r5   s    r   _default_schemaszEventLogger._default_schemash   s    r   argst.AnykwargsNonec                j    t                      j        |i | t          dz   t          t	          |                     z   }t          j        |          | _        d| j        _        | j        	                    t
          j
                   | j        r| j        D ]}|                     |           dS dS )zInitialize the logger..FN)super__init__r   stridlogging	getLogger_logger	propagatesetLevelINFOhandlersregister_handler)r6   r<   r>   log_namehandler	__class__s        r   rC   zEventLogger.__init__l   s     	$)&))) c>C4MM1(22!&gl+++= 	/= / /%%g....	/ 	// /r   cfgr   section_nameslist[str] | Nonetraitsc                    |                      |          }|                    dg           dfd}||d<   t          d|i          }t                                          |dd           dS )	zLoad EventLogger traits from a Config object, patching the
        handlers trait in the Config object to avoid deepcopy errors.
        rL   r/   list[logging.Handler]c                      S r:   r   )rL   s   r   get_handlersz.EventLogger._load_config.<locals>.get_handlers   s    Or   r)   N)rR   rT   )r/   rV   )_find_my_configpopr   rB   _load_config)	r6   rQ   rR   rT   my_cfgrX   eventlogger_cfgrL   rP   s	          @r   r[   zEventLogger._load_config~   s     %%c***0**Z*D*D	 	 	 	 	 	 *z !-!899_DNNNNNr   schemar   c                   | j                             |          }|j        }|| j        vrt	                      | j        |<   || j        vrt	                      | j        |<   || j        vrt	                      | j        |<   dS dS )zRegister this schema with the schema registry.

        Get this registered schema using the EventLogger.schema.get() method.
        N)r8   registerrE   
_modifiersset_modified_listeners_unmodified_listeners)r6   r^   event_schemakeys       r   register_event_schemaz!EventLogger.register_event_schema   s    
 |,,V44o do%%#&55DOC d...,/EED$S)d000.1eeD&s+++ 10r   rO   logging.Handlerc                     d	 fd}t          |          }|                    |            j                            |           | j        vr j                            |           dS dS )
zRegister a new logging handler to the Event Logger.

        All outgoing messages will be formatted as a JSON string.
        recordr=   r>   r/   rD   c                    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)r8   get
propertiesjsondumps)rj   r>   r^   r6   s      r   _handle_message_fieldz;EventLogger.register_handler.<locals>._handle_message_field   sM     \%%f\&:;;F 1119%:f/////r   )json_serializerN)rj   r=   r>   r=   r/   rD   )r   setFormatterrH   
addHandlerrL   append)r6   rO   rr   	formatters   `   r   rM   zEventLogger.register_handler   s    
	0 
	0 
	0 
	0 
	0 
	0 "1
 
 
	 	Y'''((($-''M  ))))) ('r   c                    | j                             |           || j        v r| j                            |           dS dS )z>Remove a logging handler from the logger and list of handlers.N)rH   removeHandlerrL   remove)r6   rO   s     r   remove_handlerzEventLogger.remove_handler   sI    ""7+++dm##M  ))))) $#r   )	schema_idr|   
str | Nonemodifier5t.Callable[[str, dict[str, t.Any]], dict[str, t.Any]]c               >   t          |          sd}t          |          |rH| j                            |t	                                }|                    |           || j        |<   dS | j        D ]*}|||k    r | j        |                             |           +dS )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	TypeErrorra   rn   rb   add)r6   r|   r~   msg	modifiersid_s         r   add_modifierzEventLogger.add_modifier   s    " !! 	!1CC..   	 ++Isuu==IMM(###)2DOI&F? 	3 	3C C9$4$4$((222	3 	3r   c                   |r"| j         |                             |           dS | j        j        D ]B}| j         |                             |           | j         |                             |           CdS )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)ra   discardr8   
schema_ids)r6   r|   r~   s      r   remove_modifierzEventLogger.remove_modifier   s    "  	=OI&..x88888 "\4 = =		*228<<<	*228<<<<= =r   )modifiedr|   r   boollistenerQt.Callable[[EventLogger, str, dict[str, t.Any]], t.Coroutine[t.Any, t.Any, None]]c               "   t          |          sd}t          |          |r|rH| j                            |t	                                }|                    |           || j        |<   dS | j                            |t	                                }|                    |           || j        |<   dS | j        j        D ]M}|||k    rC|r!| j        |                             |           -| j        |                             |           NdS )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)	r   r   rc   rn   rb   r   rd   r8   r   )r6   r   r|   r   r   	listenersr   s          r   add_listenerzEventLogger.add_listener   s0   & !! 	!1CC..   	  !488CEEJJ	h'''6?(3266y#%%HHIMM(###4=D&y1F<* 	B 	BC C9$4$4 B,S155h????.s377AAA	B 	Br   c               ,   |rB| j         |                             |           | j        |                             |           dS | j        j        D ]B}| j         |                             |           | j        |                             |           CdS )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)rc   r   rd   r8   r   )r6   r|   r   s      r   remove_listenerzEventLogger.remove_listener,  s    "  	H$Y/77AAA&y199(CCCCC "\4 H H	(3;;HEEE*95==hGGGGH Hr   )timestamp_overriderD   datadict[str, t.Any]r   datetime | Nonedict[str, t.Any] | Nonec                    j         s6 j                            |          s j                            |          sdS | j        vr!t          j        | dt          d           dS  j                            |          }t          j	        |          } j
        |j                 D ]} |||          } j        |j                 r j                            ||            j                            ||           |t          j        t          j                  n|}|                                dz   ||j        t&          d}	 t)          j        |           n# t,          $ r}	t.          |	d}	~	ww xY w|                    |            j                            |           d fd}
 j        |         D ]Q}t7          j         | ||                    } j                            |           |                    |
           R j        |         D ]W}t7          j         | ||                    } j                            |           d fd}
|                    |
           X|S )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)r|   r   )tzZ)__timestamp__rl   __schema_version____metadata_version__taskasyncio.Task[t.Any]r/   r?   c                    |                                  }|rj                            |           j                            |            d S r:   	exceptionlogerrorr.   r   r   errr6   s     r   _listener_task_donez-EventLogger.emit.<locals>._listener_task_done  sM     ..""C $s###"**400000r   )loggerr|   r   c                    |                                  }|rj                            |           j                            |            d S r:   r   r   s     r   r   z-EventLogger.emit.<locals>._listener_task_done  sM     nn&& (HNN3'''&..t44444r   )r   r   r/   r?   ) rL   rc   rn   rd   r8   warningswarnr   copydeepcopyra   rE   validate_eventr   nowr   utc	isoformatr   EVENTS_METADATA_VERSIONr   validater   r$   updaterH   infor3   create_taskr.   r   add_done_callback)r6   r|   r   r   r^   modified_datar~   	timestampcapsuler   r   r   r   s   `            r   emitzEventLogger.emitG  s   , 	,00;;	 .229==	
 4 DL((M 2 2 2 $    4!!),, d++	2 	N 	NH$Hy}MMMMM%fi0 	9L''	4888 	##I}=== .@-GHLHL))))M_ 	 '0022S8#"(.$;	
 
	-)27;;;; 	- 	- 	-#,	- 	}%%%'"""	1 	1 	1 	1 	1 	1 0; 	8 	8H &'&   D "&&t,,, ""#6777729= 	8 	8H&xxtyW['\'\'\]]D"&&t,,,5 5 5 5 5 5 ""#67777s   E   
E7*E22E7)r/   r0   )r/   r   )r<   r=   r>   r=   r/   r?   )NN)rQ   r   rR   rS   rT   rS   r/   r?   )r^   r   r/   r?   )rO   rh   r/   r?   )r|   r}   r~   r   r/   r?   )r   r   r|   r}   r   r   r/   r?   )r|   r}   r   r   r/   r?   )r|   rD   r   r   r   r   r/   r   )r   r   r   r   r   tagrL   r
   r   r8   r	   ra   rc   rd   r   r.   __annotations__r7   r   r;   rC   r[   rg   rM   r{   r   r   r   r   r   __classcell__)rP   s   @r   r)   r)   @   s          x   
cc  h  G bQRRRJ$r(cddd D
R   36#%%7777U U U U WY       / / / / / /* +/#'	O O O O O O O,4 4 4 4 * * * *4* * * * !% 3  3  3  3  3  3J !%= = = = = =:  $	*B *B *B *B *B *B^ !%H H H H H H8 `ds s s s s s s s s sr   r)   )/r   
__future__r   r3   r   rp   rF   typingtr   r   r   importlib.metadatar   
jsonschemar   packaging.versionr   	traitletsr	   r
   r   r   traitlets.configr   r   r^   r   schema_registryr   rT   r   
validatorsr   version_infopythonjsonlogger.jsonr   pythonjsonlogger.jsonloggerr   Warningr   	Exceptionr"   r$   simplefilterr'   r)   r   r   r   <module>r      s    # " " " " "          ' ' ' ' ' ' ' ' & & & & & & & & & & & & # # # # # # 2 2 2 2 2 2 2 2 2 2 2 2 8 8 8 8 8 8 8 8       + + + + + +       5 5 5 5 5 5 w+,,5%%..((3333333999999      '       I   E E E E E	 E E E  f1 2 2 2    I   z z z z z% z z z z zr   