
    g3                        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mZmZmZ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e      Z e	d
      Z e	d      Z ed       G d d             Z  edd      Z!eee gee   f   eee   e df   f   Z" G d de      Z# G d deee!         Z$ G d de$e!         Z% G d de#      Z& G d de#      Z' G d de&      Z( G d d e(      Z) G d! d"e$e(   e(      Z* G d# d$e&      Z+ G d% d&e+      Z, G d' d(e$e+   e+      Z- G d) d*e'      Z. G d+ d,e.      Z/ G d- d.e%e.   e.      Z0 G d/ d0e'      Z1 G d1 d2e1      Z2 G d3 d4e%e1   e1      Z3 G d5 d6e&      Z4 G d7 d8e4      Z5 G d9 d:e$e4   e4      Z6 G d; d<e'      Z7 G d= d>e7      Z8 G d? d@e%e7   e7      Z9 G dA dBe&      Z: G dC dDe:      Z; G dE dFe$e:   e:      Z<y)G    )ABCabstractmethod)	dataclass)	getLogger)compile)	CallableDict	GeneratorGenericIterableOptionalSequenceTypeVarUnion)metrics)Context)Observation)
Attributesz[a-zA-Z][-_./a-zA-Z0-9]{0,254}z[\x00-\x7F]{0,63}T)frozenc                        e Zd ZU dZdZeed<   y)CallbackOptionszOptions for the callback

    Args:
        timeout_millis: Timeout for the callback's execution. If the callback does asynchronous
            work (e.g. HTTP requests), it should respect this timeout.
    i'  timeout_millisN)__name__
__module____qualname____doc__r   float__annotations__     _/var/www/openai/venv/lib/python3.12/site-packages/opentelemetry/metrics/_internal/instrument.pyr   r   .   s     #NE"r    r   InstrumentT
Instrument)boundNc                   j    e Zd ZdZe	 	 d	dedededdfd       Zededededeee	e   f   fd       Z
y)
r#   z7Abstract class that serves as base for all instruments.nameunitdescriptionreturnNc                      y Nr   selfr&   r'   r(   s       r!   __init__zInstrument.__init__E        	r    c                     i }t         j                  |       | |d<   nd|d<   |d}t        j                  |      ||d<   nd|d<   |d|d<   |S ||d<   |S )as  
        Checks the following instrument name, unit and description for
        compliance with the spec.

        Returns a dict with keys "name", "unit" and "description", the
        corresponding values will be the checked strings or `None` if the value
        is invalid. If valid, the checked strings should be used instead of the
        original values.
        Nr&    r'   r(   )_name_regex	fullmatch_unit_regex)r&   r'   r(   results       r!   _check_name_unit_descriptionz'Instrument._check_name_unit_descriptionN   s     ,.  &2!F6N!F6N<D  &2!F6N!F6N$&F=!  %0F=!r    r1   r1   )r   r   r   r   r   strr.   staticmethodr	   r   r6   r   r    r!   r#   r#   B   s    A 	  	
 
     +. 	c8C= 	!   r    c            	       L    e Zd Z	 	 ddedededdfdZdd	Zedddefd
       Zy)_ProxyInstrumentr&   r'   r(   r)   Nc                 <    || _         || _        || _        d | _        y r+   )_name_unit_description_real_instrumentr,   s       r!   r.   z_ProxyInstrument.__init__s   s"     

'7;r    metermetrics.Meterc                 0    | j                  |      | _        y)z;Called when a real meter is set on the creating _ProxyMeterN)_create_real_instrumentr@   r-   rA   s     r!   on_meter_setz_ProxyInstrument.on_meter_set~   s     !% < <U Cr    c                      y)z:Create an instance of the real instrument. Implement this.Nr   rE   s     r!   rD   z(_ProxyInstrument._create_real_instrument   s    r    r7   )rA   rB   r)   N)	r   r   r   r8   r.   rF   r   r"   rD   r   r    r!   r;   r;   r   sa     		<	< 	< 		<
 
	<D I_ I I Ir    r;   c                   H     e Zd Z	 	 	 ddedeee      dededdf
 fdZ xZS )	_ProxyAsynchronousInstrumentNr&   	callbacksr'   r(   r)   c                 6    t         |   |||       || _        y r+   )superr.   
_callbacksr-   r&   rJ   r'   r(   	__class__s        r!   r.   z%_ProxyAsynchronousInstrument.__init__   s     	t[1#r    Nr1   r1   )	r   r   r   r8   r   r   	CallbackTr.   __classcell__rO   s   @r!   rI   rI      sR     48$$ HY/0$ 	$
 $ 
$ $r    rI   c                       e Zd ZdZy)Synchronousz*Base class for all synchronous instrumentsNr   r   r   r   r   r    r!   rU   rU      s    4r    rU   c                   V     e Zd ZdZe	 	 	 d	dedeee      dededdf
 fd       Z	 xZ
S )
Asynchronousz+Base class for all asynchronous instrumentsNr&   rJ   r'   r(   r)   c                 *    t         |   |||       y N)r'   r(   rL   r.   rN   s        r!   r.   zAsynchronous.__init__   s     	DkBr    rP   )r   r   r   r   r   r8   r   r   rQ   r.   rR   rS   s   @r!   rX   rX      sd    5 48CC HY/0C 	C
 C 
C Cr    rX   c            
       N    e Zd ZdZe	 	 ddeeef   dee	   dee
   ddfd       Zy)	CounterzOA Counter is a synchronous `Instrument` which supports non-negative increments.Namount
attributescontextr)   c                      y r+   r   r-   r^   r_   r`   s       r!   addzCounter.add   r/   r    NNr   r   r   r   r   r   intr   r   r   r   rc   r   r    r!   r]   r]      sX    Y ,0%)	c5j! Z( '"	
 
 r    r]   c            	       r     e Zd ZdZ	 	 ddedededdf fdZ	 	 ddeeef   d	e	e
   d
e	e   ddf fdZ xZS )NoOpCounterz"No-op implementation of `Counter`.r&   r'   r(   r)   Nc                 *    t         |   |||       y rZ   r[   r-   r&   r'   r(   rO   s       r!   r.   zNoOpCounter.__init__        	DkBr    r^   r_   r`   c                 (    t         |   |||      S N)r_   r`   rL   rc   r-   r^   r_   r`   rO   s       r!   rc   zNoOpCounter.add        w{6j'{JJr    r7   rd   r   r   r   r   r8   r.   r   rf   r   r   r   r   rc   rR   rS   s   @r!   rh   rh          ,
 	CC C 	C
 
C ,0%)	Kc5j!K Z(K '"	K
 
K Kr    rh   c            	       P    e Zd Z	 	 d
deeef   dee   dee   ddfdZ	ddde
fd	Zy)_ProxyCounterNr^   r_   r`   r)   c                 X    | j                   r| j                   j                  |||       y y r+   r@   rc   rb   s       r!   rc   z_ProxyCounter.add   *       !!%%fj'B !r    rA   rB   c                 d    |j                  | j                  | j                  | j                        S r+   )create_counterr=   r>   r?   rE   s     r!   rD   z%_ProxyCounter._create_real_instrument   s%    ##DJJ

D<M<MNNr    rd   )r   r   r   r   rf   r   r   r   r   rc   r]   rD   r   r    r!   rt   rt      sc     ,0%)	Cc5j!C Z(C '"	C
 
CO_ O Or    rt   c            
       N    e Zd ZdZe	 	 ddeeef   dee	   dee
   ddfd       Zy)	UpDownCounterzXAn UpDownCounter is a synchronous `Instrument` which supports increments and decrements.Nr^   r_   r`   r)   c                      y r+   r   rb   s       r!   rc   zUpDownCounter.add   r/   r    rd   re   r   r    r!   r{   r{      sX    b ,0%)	c5j! Z( '"	
 
 r    r{   c            	       r     e Zd ZdZ	 	 ddedededdf fdZ	 	 ddeeef   d	e	e
   d
e	e   ddf fdZ xZS )NoOpUpDownCounterz(No-op implementation of `UpDownCounter`.r&   r'   r(   r)   Nc                 *    t         |   |||       y rZ   r[   rj   s       r!   r.   zNoOpUpDownCounter.__init__   rk   r    r^   r_   r`   c                 (    t         |   |||      S rm   rn   ro   s       r!   rc   zNoOpUpDownCounter.add   rp   r    r7   rd   rq   rS   s   @r!   r~   r~      s    2
 	CC C 	C
 
C ,0%)	Kc5j!K Z(K '"	K
 
K Kr    r~   c            	       P    e Zd Z	 	 d
deeef   dee   dee   ddfdZ	ddde
fd	Zy)_ProxyUpDownCounterNr^   r_   r`   r)   c                 X    | j                   r| j                   j                  |||       y y r+   rv   rb   s       r!   rc   z_ProxyUpDownCounter.add   rw   r    rA   rB   c                 d    |j                  | j                  | j                  | j                        S r+   )create_up_down_counterr=   r>   r?   rE   s     r!   rD   z+_ProxyUpDownCounter._create_real_instrument  s*    ++JJ

D$5$5
 	
r    rd   )r   r   r   r   rf   r   r   r   r   rc   r{   rD   r   r    r!   r   r      s`     ,0%)	Cc5j!C Z(C '"	C
 
C
_ 
 
r    r   c                       e Zd ZdZy)ObservableCounterzAn ObservableCounter is an asynchronous `Instrument` which reports monotonically
    increasing value(s) when the instrument is being observed.
    NrV   r   r    r!   r   r   	  s    r    r   c                   L     e Zd ZdZ	 	 	 d	dedeee      dededdf
 fdZ xZ	S )
NoOpObservableCounterz,No-op implementation of `ObservableCounter`.Nr&   rJ   r'   r(   r)   c                 ,    t         |   ||||       y rZ   r[   rN   s        r!   r.   zNoOpObservableCounter.__init__       	ytMr    rP   
r   r   r   r   r8   r   r   rQ   r.   rR   rS   s   @r!   r   r     s\    6
 48NN HY/0N 	N
 N 
N Nr    r   c                       e Zd ZdddefdZy)_ProxyObservableCounterrA   rB   r)   c                 z    |j                  | j                  | j                  | j                  | j                        S r+   )create_observable_counterr=   rM   r>   r?   rE   s     r!   rD   z/_ProxyObservableCounter._create_real_instrument  s2     ..JJT5F5F
 	
r    N)r   r   r   r   rD   r   r    r!   r   r     s    
$
	
r    r   c                       e Zd ZdZy)ObservableUpDownCountera  An ObservableUpDownCounter is an asynchronous `Instrument` which reports additive value(s) (e.g.
    the process heap size - it makes sense to report the heap size from multiple processes and sum them
    up, so we get the total heap usage) when the instrument is being observed.
    NrV   r   r    r!   r   r   '      r    r   c                   L     e Zd ZdZ	 	 	 d	dedeee      dededdf
 fdZ xZ	S )
NoOpObservableUpDownCounterz2No-op implementation of `ObservableUpDownCounter`.Nr&   rJ   r'   r(   r)   c                 ,    t         |   ||||       y rZ   r[   rN   s        r!   r.   z$NoOpObservableUpDownCounter.__init__1  r   r    rP   r   rS   s   @r!   r   r   .  s\    <
 48NN HY/0N 	N
 N 
N Nr    r   c                       e Zd ZdddefdZy)_ProxyObservableUpDownCounterrA   rB   r)   c                 z    |j                  | j                  | j                  | j                  | j                        S r+   )!create_observable_up_down_counterr=   rM   r>   r?   rE   s     r!   rD   z5_ProxyObservableUpDownCounter._create_real_instrument?  s2     66JJT5F5F
 	
r    N)r   r   r   r   rD   r   r    r!   r   r   ;  s    
$
	 
r    r   c            
       N    e Zd ZdZe	 	 ddeeef   dee	   dee
   ddfd       Zy)		HistogramzHistogram is a synchronous `Instrument` which can be used to report arbitrary values
    that are likely to be statistically meaningful. It is intended for statistics such as
    histograms, summaries, and percentile.
    Nr^   r_   r`   r)   c                      y r+   r   rb   s       r!   recordzHistogram.recordM  r/   r    rd   )r   r   r   r   r   r   rf   r   r   r   r   r   r   r    r!   r   r   G  s\    
  ,0%)	c5j! Z( '"	
 
 r    r   c            	       r     e Zd ZdZ	 	 ddedededdf fdZ	 	 ddeeef   d	e	e
   d
e	e   ddf fdZ xZS )NoOpHistogramz$No-op implementation of `Histogram`.r&   r'   r(   r)   Nc                 *    t         |   |||       y rZ   r[   rj   s       r!   r.   zNoOpHistogram.__init__Z  rk   r    r^   r_   r`   c                 (    t         |   |||      S rm   )rL   r   ro   s       r!   r   zNoOpHistogram.recordb  s     w~fW~MMr    r7   rd   )r   r   r   r   r8   r.   r   rf   r   r   r   r   r   rR   rS   s   @r!   r   r   W  s    .
 	CC C 	C
 
C ,0%)	Nc5j!N Z(N '"	N
 
N Nr    r   c            	       P    e Zd Z	 	 d
deeef   dee   dee   ddfdZ	ddde
fd	Zy)_ProxyHistogramNr^   r_   r`   r)   c                 X    | j                   r| j                   j                  |||       y y r+   )r@   r   rb   s       r!   r   z_ProxyHistogram.recordl  s*       !!((WE !r    rA   rB   c                 d    |j                  | j                  | j                  | j                        S r+   )create_histogramr=   r>   r?   rE   s     r!   rD   z'_ProxyHistogram._create_real_instrumentu  s*    %%JJ

D$5$5
 	
r    rd   )r   r   r   r   rf   r   r   r   r   r   r   rD   r   r    r!   r   r   k  s`     ,0%)	Fc5j!F Z(F '"	F
 
F
_ 
 
r    r   c                       e Zd ZdZy)ObservableGaugezAsynchronous Gauge is an asynchronous `Instrument` which reports non-additive value(s) (e.g.
    the room temperature - it makes no sense to report the temperature value from multiple rooms
    and sum them up) when the instrument is being observed.
    NrV   r   r    r!   r   r   {  r   r    r   c                   L     e Zd ZdZ	 	 	 d	dedeee      dededdf
 fdZ xZ	S )
NoOpObservableGaugez*No-op implementation of `ObservableGauge`.Nr&   rJ   r'   r(   r)   c                 ,    t         |   ||||       y rZ   r[   rN   s        r!   r.   zNoOpObservableGauge.__init__  r   r    rP   r   rS   s   @r!   r   r     s\    4
 48NN HY/0N 	N
 N 
N Nr    r   c                       e Zd ZdddefdZy)_ProxyObservableGaugerA   rB   r)   c                 z    |j                  | j                  | j                  | j                  | j                        S r+   )create_observable_gauger=   rM   r>   r?   rE   s     r!   rD   z-_ProxyObservableGauge._create_real_instrument  s2     ,,JJT5F5F
 	
r    N)r   r   r   r   rD   r   r    r!   r   r     s    
$
	
r    r   c            
       N    e Zd ZdZe	 	 ddeeef   dee	   dee
   ddfd       Zy)	GaugezdA Gauge is a synchronous `Instrument` which can be used to record non-additive values as they occur.Nr^   r_   r`   r)   c                      y r+   r   rb   s       r!   setz	Gauge.set  r/   r    rd   )r   r   r   r   r   r   rf   r   r   r   r   r   r   r    r!   r   r     sX    n ,0%)	c5j! Z( '"	
 
 r    r   c            	       r     e Zd ZdZ	 	 ddedededdf fdZ	 	 ddeeef   d	e	e
   d
e	e   ddf fdZ xZS )	NoOpGaugez"No-op implementation of ``Gauge``.r&   r'   r(   r)   Nc                 *    t         |   |||       y rZ   r[   rj   s       r!   r.   zNoOpGauge.__init__  rk   r    r^   r_   r`   c                 (    t         |   |||      S rm   )rL   r   ro   s       r!   r   zNoOpGauge.set  rp   r    r7   rd   )r   r   r   r   r8   r.   r   rf   r   r   r   r   r   rR   rS   s   @r!   r   r     rr   r    r   c            	       P    e Zd Z	 	 d
deeef   dee   dee   ddfdZ	ddde
fd	Zy)_ProxyGaugeNr^   r_   r`   r)   c                 X    | j                   r| j                   j                  |||       y y r+   )r@   r   rb   s       r!   r   z_ProxyGauge.set  rw   r    rA   rB   c                 d    |j                  | j                  | j                  | j                        S r+   )create_gauger=   r>   r?   rE   s     r!   rD   z#_ProxyGauge._create_real_instrument  s%    !!$**djj$:K:KLLr    rd   )r   r   r   r   rf   r   r   r   r   r   r   rD   r   r    r!   r   r     sc     ,0%)	Cc5j!C Z(C '"	C
 
CM_ M Mr    r   )=abcr   r   dataclassesr   loggingr   rer   
re_compiletypingr   r	   r
   r   r   r   r   r   r   opentelemetryr   opentelemetry.contextr   +opentelemetry.metrics._internal.observationr   opentelemetry.util.typesr   r   _loggerr2   r4   r   r"   rQ   r#   r;   rI   rU   rX   r]   rh   rt   r{   r~   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r    r!   <module>r      sP  $ $ !  $
 
 
 " ) C /
H
:;-. $# # # m<8o 556h{#_d:;=	- -`IsGK0 I2	$#3K#@ 	$5* 5C: C
k 
K' K(O$W-w O
K 
K K(
*=9= 
  
N- 
N
 !235F
l 
N"9 
N	
 !89	
  NI N(
&y19 
 l 
N/ 
N	
 1	

K 
K K(MU	Mr    