
    khU                     b   d Z ddlmZmZmZmZmZ ddlZddlm	Z	 ddl
mZmZ ddl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mZ dgZddddZddddZ G d dej                  j>                        Z  G d de	jB                        Z" G d de	j>                        Z# G d de	j>                        Z$ G d de	j>                        Z% G d de	j>                        Z& G d d e	j>                        Z' G d! d"e	j>                        Z( G d# d$e	j>                        Z) G d% d&e	j>                        Z* G d' d(e	j>                        Z+ G d) de	j>                        Z,d* Z-d4d+Z. e e.d,-       e.d,-       e.d,-      d.      Z/d5d/Z0ed5d0e,fd1       Z1ed5d0e,fd2       Z2ed5d0e,fd3       Z3y)6a   EfficientFormer

@article{li2022efficientformer,
  title={EfficientFormer: Vision Transformers at MobileNet Speed},
  author={Li, Yanyu and Yuan, Geng and Wen, Yang and Hu, Eric and Evangelidis, Georgios and Tulyakov,
   Sergey and Wang, Yanzhi and Ren, Jian},
  journal={arXiv preprint arXiv:2206.01191},
  year={2022}
}

Based on Apache 2.0 licensed code at https://github.com/snap-research/EfficientFormer, Copyright (c) 2022 Snap Inc.

Modifications and timm support by / Copyright 2022, Ross Wightman
    )DictListOptionalTupleUnionNIMAGENET_DEFAULT_MEANIMAGENET_DEFAULT_STD)DropPathtrunc_normal_	to_2tupleMlpndgrid   )build_model_with_cfg)feature_take_indices)checkpoint_seq)generate_default_cfgsregister_modelEfficientFormer)0   `      i  )@      i@  i   )r        i   )l1l3l7)            )r$   r$      r#   )r#   r#         c                        e Zd ZU eeej                  f   ed<   	 	 	 	 	 d fd	Z ej                         d	 fd	       Z
dej                  dej                  fdZd Z xZS )
	Attentionattention_bias_cachec           	      \   t         |           || _        |dz  | _        || _        ||z  | _        t        ||z        | _        | j                  |z  | _        || _	        t        j                  || j
                  dz  | j                  z         | _        t        j                  | j                  |      | _        t        |      }t        j                   t#        t        j$                  |d         t        j$                  |d                     j'                  d      }|dd d d f   |dd d d f   z
  j)                         }|d   |d   z  |d   z   }t        j                  j+                  t        j,                  ||d   |d   z              | _        | j1                  d|       i | _        y )Ng      r"   r   r   .attention_bias_idxs)super__init__	num_headsscalekey_dimkey_attn_dimintval_dimval_attn_dim
attn_rationnLinearqkvprojr   torchstackr   arangeflattenabs	Parameterzerosattention_biasesregister_bufferr*   )	selfdimr1   r/   r6   
resolutionposrel_pos	__class__s	           W/var/www/teggl/fontify/venv/lib/python3.12/site-packages/timm/models/efficientformer.pyr.   zAttention.__init__.   su    	"_
#i/:/0 LL94$99S$"3"3a"7$:K:K"KLIId//5	z*
kk&jm!<ell:VW=>YZ[ccdefsAt|$s3a<'88==?1:
1-; % 2 25;;y*UV-ZdefZgJg3h i2G<$&!    c                 R    t         |   |       |r| j                  ri | _        y y y N)r-   trainr*   )rD   moderI   s     rJ   rN   zAttention.trainJ   s)    dD--(*D% .4rK   devicereturnc                 4   t         j                  j                         s| j                  r| j                  d d | j
                  f   S t        |      }|| j                  vr*| j                  d d | j
                  f   | j                  |<   | j                  |   S rM   )r;   jit
is_tracingtrainingrB   r,   strr*   )rD   rP   
device_keys      rJ   get_attention_biaseszAttention.get_attention_biasesP   s    99!T]]((D,D,D)DEEVJ!:!::8<8M8MaQUQiQiNi8j))*5,,Z88rK   c                 >   |j                   \  }}}| j                  |      }|j                  ||| j                  d      j	                  dddd      }|j                  | j                  | j                  | j                  gd      \  }}}||j                  dd      z  | j                  z  }	|	| j                  |j                        z   }	|	j                  d      }	|	|z  j                  dd      j                  ||| j                        }| j                  |      }|S )Nr   r"   r   r!   rE   )shaper9   reshaper/   permutesplitr1   r4   	transposer0   rX   rP   softmaxr5   r:   )
rD   xBNCr9   qkvattns
             rJ   forwardzAttention.forwardY   s    ''1ahhqkkk!Q3;;Aq!QG))T\\4<<FA)N1aAKKB''4::5d//99|||#AX  A&..q!T5F5FGIIaLrK   )r       r'   r$      T)__name__
__module____qualname__r   rV   r;   Tensor__annotations__r.   no_gradrN   rP   rX   rk   __classcell__rI   s   @rJ   r)   r)   +   si    sELL011 '8 U]]_+ +
95<< 9ELL 9rK   r)   c                   L     e Zd Zej                  ej
                  f fd	Z xZS )Stem4c           
         t         |           d| _        | j                  dt	        j
                  ||dz  ddd             | j                  d ||dz               | j                  d |              | j                  d	t	        j
                  |dz  |ddd             | j                  d
 ||             | j                  d |              y )Nr$   conv1r"   r!   r   kernel_sizestridepaddingnorm1act1conv2norm2act2)r-   r.   r}   
add_moduler7   Conv2d)rD   in_chsout_chs	act_layer
norm_layerrI   s        rJ   r.   zStem4.__init__i   s    67a<QWXbc!deGqL!9:	,7a<aXYcd!efG!45	,rK   )ro   rp   rq   r7   ReLUBatchNorm2dr.   ru   rv   s   @rJ   rx   rx   h   s    24''bnn 	- 	-rK   rx   c                   F     e Zd ZdZdddej
                  f fd	Zd Z xZS )
Downsamplez
    Downsampling via strided conv w/ norm
    Input: tensor in shape [B, C, H, W]
    Output: tensor in shape [B, C, H/stride, W/stride]
    r!   r"   Nc                     t         |           ||dz  }t        j                  |||||      | _         ||      | _        y )Nr"   r{   )r-   r.   r7   r   convnorm)rD   r   r   r|   r}   r~   r   rI   s          rJ   r.   zDownsample.__init__|   sB    ?!Q&GIIfg;v_fg	w'	rK   c                 J    | j                  |      }| j                  |      }|S rM   )r   r   rD   rc   s     rJ   rk   zDownsample.forward   s!    IIaLIIaLrK   )	ro   rp   rq   __doc__r7   r   r.   rk   ru   rv   s   @rJ   r   r   u   s$     56aZ\ZhZh (rK   r   c                   $     e Zd Z fdZd Z xZS )Flatc                 "    t         |           y rM   )r-   r.   )rD   rI   s    rJ   r.   zFlat.__init__   s    rK   c                 H    |j                  d      j                  dd      }|S )Nr"   r   )r>   ra   r   s     rJ   rk   zFlat.forward   s!    IIaL""1a(rK   ro   rp   rq   r.   rk   ru   rv   s   @rJ   r   r      s    rK   r   c                   *     e Zd ZdZd fd	Zd Z xZS )PoolingzP
    Implementation of pooling for PoolFormer
    --pool_size: pooling size
    c                 d    t         |           t        j                  |d|dz  d      | _        y )Nr   r"   F)r}   r~   count_include_pad)r-   r.   r7   	AvgPool2dpool)rD   	pool_sizerI   s     rJ   r.   zPooling.__init__   s)    LL1i1n`ef	rK   c                 *    | j                  |      |z
  S rM   )r   r   s     rJ   rk   zPooling.forward   s    yy|arK   )r!   )ro   rp   rq   r   r.   rk   ru   rv   s   @rJ   r   r      s    
g rK   r   c                   \     e Zd ZdZddej
                  ej                  df fd	Zd Z xZ	S )ConvMlpWithNormz`
    Implementation of MLP with 1*1 convolutions.
    Input: tensor with shape [B, C, H, W]
    N        c                    t         |           |xs |}|xs |}t        j                  ||d      | _        | ||      nt        j
                         | _         |       | _        t        j                  ||d      | _        | ||      nt        j
                         | _	        t        j                  |      | _        y )Nr   )r-   r.   r7   r   fc1Identityr   actfc2r   Dropoutdrop)rD   in_featureshidden_featuresout_featuresr   r   r   rI   s          rJ   r.   zConvMlpWithNorm.__init__   s     	#2{)8[99[/1=4>4JZ0PRP[P[P]
;99_lA>1;1GZ-R[[]
JJt$	rK   c                     | j                  |      }| j                  |      }| j                  |      }| j                  |      }| j	                  |      }| j                  |      }| j                  |      }|S rM   )r   r   r   r   r   r   r   s     rJ   rk   zConvMlpWithNorm.forward   sb    HHQKJJqMHHQKIIaLHHQKJJqMIIaLrK   )
ro   rp   rq   r   r7   GELUr   r.   rk   ru   rv   s   @rJ   r   r      s+     !gg~~%&rK   r   c                   &     e Zd Zd fd	Zd Z xZS )
LayerScalec                     t         |           || _        t        j                  |t        j                  |      z        | _        y rM   r-   r.   inplacer7   r@   r;   onesgammarD   rE   init_valuesr   rI   s       rJ   r.   zLayerScale.__init__   2    \\+

3"?@
rK   c                 n    | j                   r|j                  | j                        S || j                  z  S rM   )r   mul_r   r   s     rJ   rk   zLayerScale.forward   s(    %)\\qvvdjj!Eq4::~ErK   h㈵>Fr   rv   s   @rJ   r   r      s    A
FrK   r   c                   Z     e Zd Zdej                  ej
                  dddf fd	Zd Z xZS )MetaBlock1d      @r   r   c                 L   t         |            ||      | _        t        |      | _         ||      | _        t        |t        ||z        ||      | _        |dkD  rt        |      nt        j                         | _        t        ||      | _        t        ||      | _        y )N)r   r   r   r   r   )r-   r.   r   r)   token_mixerr   r   r3   mlpr   r7   r   	drop_pathr   ls1ls2)	rD   rE   	mlp_ratior   r   	proj_dropr   layer_scale_init_valuerI   s	           rJ   r.   zMetaBlock1d.__init__   s     	_
$S>_
i0	
 1:B),BKKMc#9:c#9:rK   c           
      
   || j                  | j                  | j                  | j                  |                        z   }|| j                  | j	                  | j                  | j                  |                        z   }|S rM   )r   r   r   r   r   r   r   r   s     rJ   rk   zMetaBlock1d.forward   sc    txx(8(8A(GHIItxxA(?@AArK   )	ro   rp   rq   r7   r   	LayerNormr.   rk   ru   rv   s   @rJ   r   r      s)    
 gg||#';2rK   r   c                   &     e Zd Zd fd	Zd Z xZS )LayerScale2dc                     t         |           || _        t        j                  |t        j                  |      z        | _        y rM   r   r   s       rJ   r.   zLayerScale2d.__init__   r   rK   c                     | j                   j                  dddd      }| j                  r|j                  |      S ||z  S )Nr   rZ   )r   viewr   r   )rD   rc   r   s      rJ   rk   zLayerScale2d.forward   s7    

2q!, $qvve};!e);rK   r   r   rv   s   @rJ   r   r      s    A
<rK   r   c                   \     e Zd Zddej                  ej
                  dddf fd	Zd Z xZS )MetaBlock2dr!   r   r   r   c	                 z   t         	|           t        |      | _        t	        ||      | _        |dkD  rt        |      nt        j                         | _	        t        |t        ||z        |||      | _        t	        ||      | _        |dkD  rt        |      | _        y t        j                         | _        y )N)r   r   )r   r   r   r   )r-   r.   r   r   r   r   r   r7   r   
drop_path1r   r3   r   r   
drop_path2)
rD   rE   r   r   r   r   r   r   r   rI   s
            rJ   r.   zMetaBlock2d.__init__   s     	"Y7%;<1:R(9-R[[]"i0!
  %;<1:R(9-R[[]rK   c                     || j                  | j                  | j                  |                  z   }|| j                  | j	                  | j                  |                  z   }|S rM   )r   r   r   r   r   r   r   s     rJ   rk   zMetaBlock2d.forward  sR    )9)9!)< =>>! 566rK   )	ro   rp   rq   r7   r   r   r.   rk   ru   rv   s   @rJ   r   r      s-    
 gg~~#'S4rK   r   c            
       v     e Zd Zddddej                  ej
                  ej                  dddf
 fd	Zd Z xZ	S )	EfficientFormerStageTr   r!   r   r   r   c                 (   t         |           d| _        |rt        |||	      | _        |}n ||k(  sJ t        j                         | _        g }|r||k\  r|j                  t                      t        |      D ]}  }||z
  dz
  }|r*||kD  r%|j                  t        ||||
|||   |             7|j                  t        |||||	|||   |             |s_||k(  se|j                  t                       t        j                  | | _        y )NF)r   r   r   r   )r   r   r   r   r   r   )r   r   r   r   r   r   r   )r-   r.   grad_checkpointingr   
downsampler7   r   appendr   ranger   r   
Sequentialblocks)rD   rE   dim_outdepthr   num_vitr   r   r   r   norm_layer_clr   r   r   r   	block_idx
remain_idxrI   s                    rJ   r.   zEfficientFormerStage.__init__  s      	"'(WQ[\DOC'>!> kkmDOw%'MM$&!u 	*I*Q.J7Z/"+"+#0"+"+I"6/E	 "+"+"+#-"+"+I"6/E	
 w*4MM$&)5	*8 mmV,rK   c                     | j                  |      }| j                  r6t        j                  j	                         st        | j                  |      }|S | j                  |      }|S rM   )r   r   r;   rS   is_scriptingr   r   r   s     rJ   rk   zEfficientFormerStage.forward[  sS    OOA""599+A+A+Ct{{A.A  AArK   )
ro   rp   rq   r7   r   r   r   r.   rk   ru   rv   s   @rJ   r   r     s:     gg~~,,#':-xrK   r   c                       e Zd Zdddddddddej                  ej
                  ej                  dddf fd		Zd
 Ze	j                  j                  d        Ze	j                  j                  d"d       Ze	j                  j                  d#d       Ze	j                  j                  dej                  fd       Zd$dedee   fdZe	j                  j                  d#d       Z	 	 	 	 	 d%de	j,                  deeeee   f      dededededeee	j,                     ee	j,                  ee	j,                     f   f   fdZ	 	 	 d&deeee   f   dedefdZd Zd"defd Zd! Z xZ S )'r   Nr!     avgr   r$   r   r   c                    t         |           || _        || _        t	        ||d   |      | _        |d   }t        |      | _        | j                  dz
  }t        j                  d|t        |            j                  |      D cg c]  }|j                          }}|xs dd| j                  dz
  z  z   }g }g | _        t        | j                        D ]q  }t        |||   ||   ||   ||k(  r|nd|	|||||||   |
      }||   }|j!                  |       | xj                  t#        ||   d|dz   z  d| 	      gz  c_        s t%        j&                  | | _        |d
   x| _        | _         || j*                        | _        t%        j0                  |      | _        |dkD  r t%        j4                  | j*                  |      nt%        j6                         | _        |dkD  rt%        j4                  |d
   |      nt%        j6                         | _        d| _        | j?                  | j@                         y c c}w )Nr   )r   r   Frn   )
r   r   r   r   r   r   r   r   r   r   r"   stages.)num_chs	reductionmodulerZ   F)!r-   r.   num_classesglobal_poolrx   stemlen
num_stagesr;   linspacesumr`   tolistfeature_infor   r   r   dictr7   r   stagesnum_featureshead_hidden_sizer   r   	head_dropr8   r   head	head_distdistilled_trainingapply_init_weights)rD   depths
embed_dimsin_chansr   r   downsamplesr   
mlp_ratiosr   r   r   r   r   	drop_rateproj_drop_ratedrop_path_ratekwargsprev_dim
last_stagerc   dprr   istagerI   s                            rJ   r.   zEfficientFormer.__init__f  s#   ( 	&&(JqMjI	a= f+__q(
#(>>!^S[#Q#W#WX^#_`aqxxz``!OX4??Q;N0O%Ot' 	iA(1q	&q>#$
?#$#+%(a&'=E "!}HMM% $z!}AaC[bcdbeYf"g!hh%	i& mmV, 5?rNBD1!$"3"34	I.ALqBIId//=VXVaVaVc	CNQR?:b>;?XZXcXcXe"'

4%%&E as   	H>c                    t        |t        j                        rjt        |j                  d       t        |t        j                        r8|j
                  +t        j                  j                  |j
                  d       y y y y )Ng{Gz?)stdr   )
isinstancer7   r8   r   weightbiasinit	constant_)rD   ms     rJ   r  zEfficientFormer._init_weights  sZ    a#!((,!RYY'AFF,>!!!&&!, -?' $rK   c                 ^    | j                         D ch c]  \  }}d|v s| c}}S c c}}w )NrB   )named_parameters)rD   rh   _s      rJ   no_weight_decayzEfficientFormer.no_weight_decay  s+    "335Qda9Kq9PQQQs   ))c                 $    t        dddg      }|S )Nz^stem)z^stages\.(\d+)N)z^norm)i )r   r   )r   )rD   coarsematchers      rJ   group_matcherzEfficientFormer.group_matcher  s    -/CD
 rK   c                 4    | j                   D ]	  }||_         y rM   )r   r   )rD   enabless      rJ   set_grad_checkpointingz&EfficientFormer.set_grad_checkpointing  s     	*A#)A 	*rK   rQ   c                 2    | j                   | j                  fS rM   r   r   )rD   s    rJ   get_classifierzEfficientFormer.get_classifier  s    yy$..((rK   r   r   c                 (   || _         ||| _        |dkD  r t        j                  | j                  |      nt        j
                         | _        |dkD  r&t        j                  | j                  |      | _        y t        j
                         | _        y )Nr   )r   r   r7   r8   r   r   r   r   )rD   r   r   s      rJ   reset_classifierz EfficientFormer.reset_classifier  sq    &"*DALqBIId//=VXVaVaVc	FQTUo4#4#4kB[][f[f[hrK   c                     || _         y rM   )r  )rD   r#  s     rJ   set_distilled_trainingz&EfficientFormer.set_distilled_training  s
    "(rK   rc   indicesr   
stop_early
output_fmtintermediates_onlyc           	         |dv sJ d       g }t        t        | j                        |      \  }}	| j                  |      }|j                  \  }
}}}| j
                  dz
  }t        j                  j                         s|s| j                  }n| j                  d|	dz    }d}t        |      D ]  \  }} ||      }||k  r|j                  \  }
}}}||v s)||k(  rQ|r| j                  |      n|}|j                  |j                  |
|dz  |dz  d      j                  dddd             |j                  |        |r|S ||k(  r| j                  |      }||fS )	a   Forward features that returns intermediates.

        Args:
            x: Input image tensor
            indices: Take last n blocks if int, all if None, select matching indices if sequence
            norm: Apply norm layer to compatible intermediates
            stop_early: Stop iterating over blocks when last desired intermediate hit
            output_fmt: Shape of intermediate feature outputs
            intermediates_only: Only return intermediate features
        Returns:

        )NCHWzOutput shape must be NCHW.r   Nr   r"   rZ   r!   )r   r   r   r   r]   r   r;   rS   r   	enumerater   r   r^   r_   )rD   rc   r-  r   r.  r/  r0  intermediatestake_indices	max_indexrd   rf   HWlast_idxr   feat_idxr  x_inters                      rJ   forward_intermediatesz%EfficientFormer.forward_intermediates  sg   * Y&D(DD&"6s4;;7G"Qi IIaLWW
1a??Q&99!!#:[[F[[)a-0F(0 		,OHeaA("WW
1a<'x'.2diilG!((AFAFB)O)W)WXY[\^_ab)cd!((+		,   x		!A-rK   
prune_norm
prune_headc                     t        t        | j                        |      \  }}| j                  d|dz    | _        |rt        j                         | _        |r| j                  dd       |S )z@ Prune layers not required for specified intermediates.
        Nr   r    )r   r   r   r7   r   r   r*  )rD   r-  r=  r>  r5  r6  s         rJ   prune_intermediate_layersz)EfficientFormer.prune_intermediate_layers  s]     #7s4;;7G"Qikk.9q=1DI!!!R(rK   c                 l    | j                  |      }| j                  |      }| j                  |      }|S rM   )r   r   r   r   s     rJ   forward_featuresz EfficientFormer.forward_features  s.    IIaLKKNIIaLrK   
pre_logitsc                 6   | j                   dk(  r|j                  d      }| j                  |      }|r|S | j                  |      | j	                  |      }}| j
                  r.| j                  r"t        j                  j                         s||fS ||z   dz  S )Nr   r   r[   r"   )
r   meanr   r   r   r  rU   r;   rS   r   )rD   rc   rD  x_dists       rJ   forward_headzEfficientFormer.forward_head  s    u$1ANN1HIIaL$.."36""t}}UYY=S=S=Uf9 J!##rK   c                 J    | j                  |      }| j                  |      }|S rM   )rC  rH  r   s     rJ   rk   zEfficientFormer.forward)  s'    !!!$a rK   r   rn   rM   )NFFr2  F)r   FT)!ro   rp   rq   r7   r   r   r   r.   r  r;   rS   ignorer  r!  r%  Moduler(  r3   r   rV   r*  r,  rr   r   r   boolr   r<  rA  rC  rH  rk   ru   rv   s   @rJ   r   r   d  s   
 #'gg~~,,#@'F- YYR R YY  YY* * YY)		 ) )iC ihsm i YY) ) 8<$$',4 ||4  eCcN344  	4 
 4  4  !%4  
tELL!5tELL7I)I#JJ	K4 p ./$#	3S	>*  	 $$ $rK   c                    d| v r| S i }ddl }d}| j                         D ]  \  }}|j                  d      rH|j                  dd      }|j                  dd      }|j                  d	d
      }|j                  dd      }|j	                  d|      r|dz  }|j                  dd| d|      }|j                  dd| d|      }|j                  dd| d|      }|j                  dd|      }|j                  dd      }|||<    |S )z$ Remap original checkpoints -> timm zstem.0.weightr   Npatch_embedzpatch_embed.0
stem.conv1zpatch_embed.1z
stem.norm1zpatch_embed.3z
stem.conv2zpatch_embed.4z
stem.norm2znetwork\.(\d+)\.proj\.weightr   znetwork.(\d+).(\d+)r   z
.blocks.\2znetwork.(\d+).projz.downsample.convznetwork.(\d+).normz.downsample.normzlayer_scale_([0-9])z
ls\1.gamma	dist_headr   )reitems
startswithreplacematchsub)
state_dictmodelout_dictrQ  	stage_idxrh   ri   s          rJ   checkpoint_filter_fnr[  /  s(   *$HI  " 1<<&		/<8A		/<8A		/<8A		/<8A883Q7NIFF)WYK{+KQOFF(GI;>N*OQRSFF(GI;>N*OQRSFF)=!<IIk;/  OrK   c                 2    | ddd dddt         t        ddd|S )	Nr   )r!   r   r   Tgffffff?bicubicrO  r'  )urlr   
input_sizer   fixed_input_sizecrop_pctinterpolationrF  r  
first_conv
classifierr   )r^  r  s     rJ   _cfgre  J  s4    =tae)%.B"2G  rK   ztimm/)	hf_hub_id)z!efficientformer_l1.snap_dist_in1kz!efficientformer_l3.snap_dist_in1kz!efficientformer_l7.snap_dist_in1kc                 r    |j                  dd      }t        t        | |ft        t	        |d      d|}|S )Nout_indicesr$   getter)rh  feature_cls)pretrained_filter_fnfeature_cfg)popr   r   r[  r   )variant
pretrainedr  rh  rX  s        rJ   _create_efficientformerrp  b  sF    **]A.K *1[hG 	E LrK   rQ   c           	      h    t        t        d   t        d   d      }t        dd| it        |fi |S )Nr   r   r  r  r   ro  )efficientformer_l1r   EfficientFormer_depthEfficientFormer_widthrp  ro  r  
model_argss      rJ   rs  rs  m  A    $T*(.J
 #mJmRVWaRlekRlmmrK   c           	      h    t        t        d   t        d   d      }t        dd| it        |fi |S )Nr   r$   rr  ro  )efficientformer_l3rt  rw  s      rJ   r{  r{  w  ry  rK   c           	      h    t        t        d   t        d   d      }t        dd| it        |fi |S )Nr    r'   rr  ro  )efficientformer_l7rt  rw  s      rJ   r}  r}    ry  rK   )r@  r   )4r   typingr   r   r   r   r   r;   torch.nnr7   	timm.datar	   r
   timm.layersr   r   r   r   r   _builderr   	_featuresr   _manipulater   	_registryr   r   __all__rv  ru  rK  r)   r   rx   r   r   r   r   r   r   r   r   r   r   r[  re  default_cfgsrp  rs  r{  r}   rK   rJ   <module>r     s   6 5   A G G * + ' <
 

  

 : :z
-BMM 
- (299  bii  !bii !HF F")) B<299 <")) DD299 DNHbii HV6 %)-* *.* *.*
& 
 no n n no n n no n nrK   