§
    .P„jÚp  ã                  ó  — U 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	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 ddlmZ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!m"Z"m#Z#m$Z$ ddl%m&Z&m'Z'm(Z(m)Z)m*Z* 	 ddlm&Z+ n# e,$ r e&Z+Y nw xY wdŸd„Z-d„ Z.d d„Z/d¡d„Z0 ee1¦  «        Z2d„  e3e¦  «        D ¦   «         Z4 e"d¦  «        Z5 e"d¦  «        Z6 e"d¦  «        Z7 e"d¦  «        Z8 e"d¦  «        Z9 G d„ de'¦  «        Z:d¢d"„Z;d£d$„Z< e"d%e:¬&¦  «        Z=e#e>e?e@eAf         ZBe#eCeB         eDeeBf         eEeB         f         ZFeDe5e#e8d'f         f         ZGee5e#e8d(f         f         ZHd¤d+„ZI G d,„ d-eJ¦  «        ZKd.„ ZLg d/¢ZMd0eNd1<   g d2¢ZOd0eNd3<   d¥d6„ZPd¦d9„ZQd§d;„ZRd¨d?„ZSd©d@„ZTd©dA„ZUd©dB„ZVd©dC„ZWd©dD„ZXd©dE„ZYd©dF„ZZd©dG„Z[d©dH„Z\d©dI„Z]dªdK„Z^d¤dL„Z_d©dM„Z`d©dN„Zad©dO„Zbd«dQ„Zcd¬dS„Zdd­dU„Zed®dW„Zf	 d¯d°d[„Zgd±d]„Zhd²da„Zid³db„Zjd´de„Zkdf„ Zldµdi„Zmd¶dm„Znd·ds„Zod¸d¹dw„Zpdºd{„Zqd»d~„Zrd¼d€„Zsd�eDd‚œd½d„„Ztd¾d‡„Zud¿dŠ„ZvdÀdÁd�„Zw	 dÂdÃd“„Zxe$dÄd–„¦   «         Zye$dÅd™„¦   «         ZyefdÆdš„ZydÇd�„Zze1džk    rddl{Z{ e{j|        ¦   «          dS dS )ÈzFUtility functions used in various parts of the simple_parsing package.é    )ÚannotationsN)ÚOrderedDictÚdefaultdict)Úabc)Ú	ContainerÚIterableÚMappingÚMutableMapping)Ú_MISSING_TYPEÚMISSINGÚField)ÚEnum)Ú	getLogger)ÚAnyÚCallableÚClassVarÚ
ForwardRefÚTypeVarÚUnionÚoverload)ÚLiteralÚProtocolÚ	TypeGuardÚget_argsÚ
get_origin)r   ÚreturnÚboolc                ó.   — t          | ¦  «        t          u S ©N)Útyper   ©Úts    úY/root/disk_3tb/conda_envs/Huy-visual/lib/python3.11/site-packages/simple_parsing/utils.pyÚ
is_typevarr$   *   s   € Ý�‰7Œ7•gÐÐó    c                óf   — t          | ¦  «        rt          | dd ¦  «        S t          d| › �¦  «        ‚)NÚ	__bound__ztype is not a `TypeVar`: )r$   ÚgetattrÚ	TypeErrorr!   s    r#   Ú	get_boundr*   .   s9   € Ý�!�}„}ð 9Ý�q˜+ tÑ,Ô,Ð,åÐ7°AÐ7Ð7Ñ8Ô8Ð8r%   úTypeGuard[typing.ForwardRef]c                ó6   — t          | t          j        ¦  «        S r   )Ú
isinstanceÚtypingr   r!   s    r#   Úis_forward_refr/   5   s   € Ý�a�Ô*Ñ+Ô+Ð+r%   Úfrr   Ústrc                ó"   — t          | d¦  «        S )NÚ__forward_arg__)r(   )r0   s    r#   Úget_forward_argr4   9   s   € Ý�2Ð(Ñ)Ô)Ð)r%   c                óˆ   — g | ]?}t          t          t          |¦  «        t          ¦  «        ¯*t          t          |¦  «        ‘Œ@S © )r-   r(   Úbuiltinsr    )Ú.0Úds     r#   ú
<listcomp>r:   ?   sM   € ð ð ð Øµ:½gÅhÐPQÑ>RÔ>RÕTXÑ3YÔ3YðÝ�H�aÑÔðð ð r%   ÚKÚTÚUÚVÚWc                  ó   — e Zd ZU ded<   dS )Ú	DataclasszClassVar[dict[str, Field]]Ú__dataclass_fields__N)Ú__name__Ú
__module__Ú__qualname__Ú__annotations__r6   r%   r#   rA   rA   J   s   € € € € € € Ø4Ð4Ð4Ñ4Ð4Ð4r%   rA   Úobjr   úTypeGuard[Dataclass]c                ól   — t          j        | ¦  «        o t          j        t          | ¦  «        ¦  «        S r   )ÚdataclassesÚis_dataclassr    ©rG   s    r#   Úis_dataclass_instancerM   N   s)   € ÝÔ# CÑ(Ô(ÐP­[Ô-EÅdÈ3ÁiÄiÑ-PÔ-PÐPr%   úTypeGuard[type[Dataclass]]c                óR   — t          j        | ¦  «        ot          j        | ¦  «        S r   )ÚinspectÚisclassrJ   rK   rL   s    r#   Úis_dataclass_typerR   R   s"   € ÝŒ?˜3ÑÔÐA¥KÔ$<¸SÑ$AÔ$AÐAr%   Ú
DataclassT)ÚboundúPossiblyNestedDict[K, V]úPossiblyNestedMapping[K, V]Úfieldr   c                ó  — t          | j        ¦  «        rJt          | ¦  «        s;t          | j        ¦  «        }t	          t          t          j        |¦  «        ¦  «        S t          | j	         
                    di ¦  «        ¦  «        S )NÚ
subparsers)Úis_unionr    Ú	is_choiceÚget_type_argumentsÚallÚmaprJ   rK   r   ÚmetadataÚget)rW   Útype_argumentss     r#   Úis_subparser_fieldrb   _   so   € Ý�”
ÑÔð B¥I¨eÑ$4Ô$4ð BÝ+¨E¬JÑ7Ô7ˆÝ•3•{Ô/°Ñ@Ô@ÑAÔAÐAÝ�”×"Ò" <°Ñ4Ô4Ñ5Ô5Ð5r%   c                  ó"   ‡ — e Zd ZdZˆ fd„Zˆ xZS )ÚInconsistentArgumentErrorzyError raised when the number of arguments provided is inconsistent when parsing multiple
    instances from command line.c                ó:   •—  t          ¦   «         j        |i |¤Ž d S r   )ÚsuperÚ__init__)ÚselfÚargsÚkwargsÚ	__class__s      €r#   rg   z"InconsistentArgumentError.__init__j   s%   ø€ Ø�‰ŒÔ˜$Ð) &Ð)Ð)Ð)Ð)Ð)r%   )rC   rD   rE   Ú__doc__rg   Ú__classcell__)rk   s   @r#   rd   rd   f   sB   ø€ € € € € ð$ð $ð*ð *ð *ð *ð *ð *ð *ð *ð *r%   rd   c                ó~   — t          j        dd| ¦  «        }t          j        dd|¦  «                             ¦   «         S )Nz(.)([A-Z][a-z]+)z\1_\2z([a-z0-9])([A-Z]))ÚreÚsubÚlower)ÚnameÚs1s     r#   Ú
camel_casert   n   s7   € Ý	ŒÐ" H¨dÑ	3Ô	3€BÝŒ6Ð% x°Ñ4Ô4×:Ò:Ñ<Ô<Ð<r%   )ÚyesÚtruer"   ÚyÚ1z	list[str]ÚTRUE_STRINGS)ÚnoÚfalseÚfÚnÚ0ÚFALSE_STRINGSÚ	raw_valueú
str | boolc                óØ   — t          | t          ¦  «        r| S |                      ¦   «                              ¦   «         }|t          v rdS |t
          v rdS t          j        d| › d�¦  «        ‚)zbTaken from https://stackoverflow.com/questions/15008758/parsing-boolean-values-with-
    argparse.TFz/Boolean value expected for argument, received 'ú')r-   r   Ústriprq   ry   r   ÚargparseÚArgumentTypeError)r€   Úvs     r#   Ústr2boolrˆ   w   sz   € õ �)�TÑ"Ô"ð ØÐØ�ŠÑÔ×ÒÑ!Ô!€AØ�LÐÐØˆtØ	
�mÐ	Ð	ØˆuåÔ(ØJ¸iÐJÐJÐJñ
ô 
ð 	
r%   Úcontainer_typeútype[Container[T]]c           
     óÈ   — | t           t          t          t           t          t          t          t          t
          h	v rt          S t          | dd¦  «        }|r|d         S t          S )aº  Returns the `type` of the items in the provided container `type`.

    When no type annotation is found, or no item type is found, returns
    `typing.Any`.
    NOTE: If a type with multiple arguments is passed, only the first type
    argument is returned.

    >>> import typing
    >>> from typing import List, Tuple
    >>> get_item_type(list)
    typing.Any
    >>> get_item_type(List)
    typing.Any
    >>> get_item_type(tuple)
    typing.Any
    >>> get_item_type(Tuple)
    typing.Any
    >>> get_item_type(List[int])
    <class 'int'>
    >>> get_item_type(List[str])
    <class 'str'>
    >>> get_item_type(List[float])
    <class 'float'>
    >>> get_item_type(List[float])
    <class 'float'>
    >>> get_item_type(List[Tuple])
    typing.Tuple
    >>> get_item_type(List[Tuple[int, int]])
    typing.Tuple[int, int]
    >>> get_item_type(Tuple[int, str])
    <class 'int'>
    >>> get_item_type(Tuple[str, int])
    <class 'str'>
    >>> get_item_type(Tuple[str, str, str, str])
    <class 'str'>

    Arguments:
        list_type {Type} -- A type, preferably one from the Typing module (List, Tuple, etc).

    Returns:
        Type -- the type of the container's items, if found, else Any.
    Ú__args__Nr   )ÚlistÚsetÚtupleÚdictr	   r
   r   r(   )r‰   ra   s     r#   Úget_item_typer‘   ‡   sb   € ðV ÝÝÝÝÝÝÝÝÝð
ð 
ð 
õ ˆ
Ý˜^¨Z¸Ñ>Ô>€NØð Ø˜aÔ Ð åˆ
r%   útype[T] | Callable[[str], T]c                ó¤   — t          | ¦  «        }|t          u rt          S |t          u rt          S t          |¦  «        rddlm}  ||¦  «        S |S )aÐ  Gets the argparse 'type' option to be used for a given container type. When an annotation is
    present, the 'type' option of argparse is set to that type. if not, then the default value of
    'str' is returned.

    Arguments:
        container_type {Type} -- A container type (ideally a typing.Type such as List, Tuple, along with an item annotation: List[str], Tuple[int, int], etc.)

    Returns:
        typing.Type -- the type that should be used in argparse 'type' argument option.

    TODO: This overlaps in a weird way with `get_parsing_fn`, which returns the 'type'
    to use for a given annotation! This function however doesn't deal with 'weird' item
    types, it just returns the first annotation.
    r   )Ú
parse_enum)r‘   r   rˆ   r   r1   Úis_enumÚ%simple_parsing.wrappers.field_parsingr”   )r‰   r<   r”   s      r#   Úget_argparse_type_for_containerr—   Æ   sc   € õ" 	�nÑ%Ô%€AØ�D€y€yÝˆØ�C€x€xÝˆ
Ýˆq�z„zð ð 	EÐDÐDÐDÐDÐDàˆz˜!‰}Œ}ÐØ€Hr%   r"   r    ú
list[type]c                óÜ   — | €g S t          | d¦  «        r| j        S t          | ¦  «        t          u rg S t          | d¦  «        r(t	          | j        ¦  «        r|                      ¦   «         S g S )NÚ__mro__Úmro)Úhasattrrš   r   r    Úcallabler›   r!   s    r#   Ú_mrorž   æ   sq   € ð 	€yØˆ	Ýˆq�)ÑÔð ØŒyÐÝ	�A‰Œ�$Ð	Ð	Øˆ	Ý	��EÑ	Ô	ð �x¨¬™œð Ø�uŠu‰wŒwˆØ€Ir%   c                ó<   — t          | ¦  «        t          t          fv S )a†  Returns True with `t` is a Literal type.

    >>> from typing_extensions import Literal
    >>> from typing import *
    >>> is_literal(list)
    False
    >>> is_literal("foo")
    False
    >>> is_literal(Literal[True, False])
    True
    >>> is_literal(Literal[1,2,3])
    True
    >>> is_literal(Literal["foo", "bar"])
    True
    >>> is_literal(Optional[Literal[1,2]])
    False
    )r   r   Ú
LiteralAltr!   s    r#   Ú
is_literalr¡   ô   s   € õ$ �a‰=Œ=�W¥jÐ1Ð1Ð1r%   c                ó.   — t           t          | ¦  «        v S )aï  Returns True when `t` is a List type.

    Args:
        t (Type): a type.

    Returns:
        bool: True if `t` is list or a subclass of list.

    >>> from typing import *
    >>> is_list(list)
    True
    >>> is_list(tuple)
    False
    >>> is_list(List)
    True
    >>> is_list(List[int])
    True
    >>> is_list(List[Tuple[int, str, None]])
    True
    >>> is_list(Optional[List[int]])
    False
    >>> class foo(List[int]):
    ...   pass
    ...
    >>> is_list(foo)
    True
    )r�   rž   r!   s    r#   Úis_listr£   	  s   € õ8 •4˜‘7”7ˆ?Ðr%   c                ó.   — t           t          | ¦  «        v S )aç  Returns True when `t` is a tuple type.

    Args:
        t (Type): a type.

    Returns:
        bool: True if `t` is tuple or a subclass of tuple.

    >>> from typing import *
    >>> is_tuple(list)
    False
    >>> is_tuple(tuple)
    True
    >>> is_tuple(Tuple)
    True
    >>> is_tuple(Tuple[int])
    True
    >>> is_tuple(Tuple[int, str, None])
    True
    >>> class foo(tuple):
    ...   pass
    ...
    >>> is_tuple(foo)
    True
    >>> is_tuple(List[int])
    False
    )r�   rž   r!   s    r#   Úis_tupler¥   (  s   € õ8 •D˜‘G”GÐÐr%   c                ó`   — t          | ¦  «        }t          |v pt          |v pt          j        |v S )al  Returns True when `t` is a dict type or annotation.

    Args:
        t (Type): a type.

    Returns:
        bool: True if `t` is dict or a subclass of dict.

    >>> from typing import *
    >>> from collections import OrderedDict
    >>> is_dict(dict)
    True
    >>> is_dict(OrderedDict)
    True
    >>> is_dict(tuple)
    False
    >>> is_dict(Dict)
    True
    >>> is_dict(Dict[int, float])
    True
    >>> is_dict(Dict[Any, Dict])
    True
    >>> is_dict(Optional[Dict])
    False
    >>> is_dict(Mapping[str, int])
    True
    >>> class foo(Dict):
    ...   pass
    ...
    >>> is_dict(foo)
    True
    )rž   r�   r	   Úc_abc)r"   r›   s     r#   Úis_dictr¨   G  s/   € õB ˆq‰'Œ'€CÝ�3ˆ;Ð@�' S˜.Ð@­E¬M¸SÐ,@Ð@r%   c                ó.   — t           t          | ¦  «        v S )aø  Returns True when `t` is a set type or annotation.

    Args:
        t (Type): a type.

    Returns:
        bool: True if `t` is set or a subclass of set.

    >>> from typing import *
    >>> is_set(set)
    True
    >>> is_set(Set)
    True
    >>> is_set(tuple)
    False
    >>> is_set(Dict)
    False
    >>> is_set(Set[int])
    True
    >>> is_set(Set["something"])
    True
    >>> is_set(Optional[Set])
    False
    >>> class foo(Set):
    ...   pass
    ...
    >>> is_set(foo)
    True
    )rŽ   rž   r!   s    r#   Úis_setrª   l  s   € õ< •$�q‘'”'ˆ>Ðr%   c                óŠ   — t          j        | ¦  «        p/t          | ¦  «        o t          j        t          | ¦  «        ¦  «        S )z®Returns whether t is a dataclass type or a TypeVar of a dataclass type.

    Args:
        t (Type): Some type.

    Returns:
        bool: Whether its a dataclass type.
    )rJ   rK   r$   r*   r!   s    r#   Úis_dataclass_type_or_typevarr¬   �  s;   € õ Ô# AÑ&Ô&ð Ý�1‰ŒÐ@�+Ô2µ9¸Q±<´<Ñ@Ô@ðr%   c                óŠ   — t          j        | ¦  «        rt          | t          j        ¦  «        S t          t          | ¦  «        v S r   )rP   rQ   Ú
issubclassÚenumr   rž   r!   s    r#   r•   r•   ›  s6   € Ý„�qÑÔð (Ý˜!�TœYÑ'Ô'Ð'Ý•4˜‘7”7ˆ?Ðr%   c                ó.   — t           t          | ¦  «        v S r   )r   rž   r!   s    r#   Úis_boolr±   ¡  s   € Ý•4˜‘7”7ˆ?Ðr%   c                ó>   — t          | ¦  «        pt          | ¦  «        S r   )r£   r¥   r!   s    r#   Úis_tuple_or_listr³   ¥  s   € Ý�1‰:Œ:Ð$� !™œÐ$r%   c                óž   — t           j        dd…         dk    rt          | t          j        ¦  «        rdS t          | dd¦  «        t          k    S )a�  Returns whether or not the given Type annotation is a variant (or subclass) of typing.Union.

    Args:
        t (Type): some type annotation

    Returns:
        bool: Whether this type represents a Union type.

    >>> from typing import *
    >>> is_union(Union[int, str])
    True
    >>> is_union(Union[int, str, float])
    True
    >>> is_union(Tuple[int, str])
    False
    Né   )é   é
   TÚ
__origin__Ú )ÚsysÚversion_infor-   ÚtypesÚ	UnionTyper(   r   r!   s    r#   rZ   rZ   ©  sH   € õ" Ô˜˜˜Ô˜wÒ&Ð&­:°a½¼Ñ+IÔ+IÐ&ØˆtÝ�1�l BÑ'Ô'­5Ò0Ð0r%   útype[tuple]c                ó  — t          | ¦  «        sdS t          | ¦  «        }|sdS t          |t          ¦  «        s
J |¦   «         ‚t	          |¦  «        dk    r|d         t
          u rdS t	          t          |¦  «        ¦  «        dk    S )a†  Returns whether the given Tuple type is homogeneous: if all items types are the same.

    This also includes Tuple[<some_type>, ...]

    Returns
    -------
    bool

    >>> from typing import *
    >>> is_homogeneous_tuple_type(Tuple)
    True
    >>> is_homogeneous_tuple_type(Tuple[int, int])
    True
    >>> is_homogeneous_tuple_type(Tuple[int, str])
    False
    >>> is_homogeneous_tuple_type(Tuple[int, str, float])
    False
    >>> is_homogeneous_tuple_type(Tuple[int, ...])
    True
    >>> is_homogeneous_tuple_type(Tuple[Tuple[int, str], ...])
    True
    >>> is_homogeneous_tuple_type(Tuple[List[int], List[str]])
    False
    FTrµ   é   )r¥   r\   r-   r�   ÚlenÚEllipsisrŽ   )r"   ra   s     r#   Úis_homogeneous_tuple_typerÃ   ¿  s“   € õ2 �A‰;Œ;ð ØˆuÝ'¨Ñ*Ô*€NØð ØˆtÝ�n¥eÑ,Ô,Ð<Ð<¨nÑ<Ô<Ð,Ý
ˆ>ÑÔ˜aÒÐ N°1Ô$5½Ð$AÐ$AØˆtõ �s�>Ñ"Ô"Ñ#Ô# qÒ(Ð(r%   c                óz   — t          | j                             di ¦  «                             di ¦  «        ¦  «        S )NÚcustom_argsÚchoices)r   r_   r`   )rW   s    r#   r[   r[   æ  s2   € Ý�”×"Ò" =°"Ñ5Ô5×9Ò9¸)ÀRÑHÔHÑIÔIÐIr%   c                ó¨   — t          | ¦  «        r t          d¦  «        t          | ¦  «        v rdS t          | ¦  «        rdt          | ¦  «        v rdS dS )a}  Returns True if the given Type is a variant of the Optional type.

    Parameters
    ----------
    - t : Type

        a Type annotation (or "live" type)

    Returns
    -------
    bool
        Whether or not this is an Optional.

    >>> from typing import Union, Optional, List, Literal
    >>> is_optional(str)
    False
    >>> is_optional(Optional[str])
    True
    >>> is_optional(Union[str, None])
    True
    >>> is_optional(Union[str, List])
    False
    >>> is_optional(Union[str, List, int, float, None])
    True
    >>> is_optional(Literal["a", None, "b"])
    True
    >>> is_optional(Literal["a", 1])
    False
    NTF)rZ   r    r\   r¡   r!   s    r#   Úis_optionalrÈ   ê  s[   € õ< ��{„{ð •t˜D‘z”zÕ%7¸Ñ%:Ô%:Ð:Ð:ØˆtÝ	�A‰Œð ˜4Õ#5°aÑ#8Ô#8Ð8Ð8Øˆtàˆur%   c                óX   — t          | ¦  «        ot          t          | ¦  «        ¦  «        S r   )r³   r¬   r‘   r!   s    r#   Úis_tuple_or_list_of_dataclassesrÊ     s&   € Ý˜AÑÔÐQÕ#?ÅÈaÑ@PÔ@PÑ#QÔ#QÐQr%   c                ó´   — t          | ¦  «        rdS t          | ¦  «        rdS t          | ¦  «        r&t          d„ t	          | ¦  «        D ¦   «         ¦  «        S dS )NTc              3  ó4   K  — | ]}t          |¦  «        V — Œd S r   )Úcontains_dataclass_type_arg©r8   Úargs     r#   ú	<genexpr>z.contains_dataclass_type_arg.<locals>.<genexpr>  s+   è è € ÐUÐU¸Õ.¨sÑ3Ô3ÐUÐUÐUÐUÐUÐUr%   F)r¬   rÊ   rZ   Úanyr\   r!   s    r#   rÍ   rÍ     si   € Ý# AÑ&Ô&ð VØˆtÝ	(¨Ñ	+Ô	+ð VØˆtÝ	�!‰Œð VÝÐUÐUÕ?QÐRSÑ?TÔ?TÐUÑUÔUÑUÔUÐUØˆ5r%   útype | Nonec           	     óð   — t          | ¦  «        sd S t          | ¦  «        r| S t          | ¦  «        st          | ¦  «        r5t	          t          d d„ t          | ¦  «        D ¦   «         ¦  «        d ¦  «        S d S )Nc              3  ó4   K  — | ]}t          |¦  «        V — Œd S r   )Úget_dataclass_type_argrÎ   s     r#   rÐ   z)get_dataclass_type_arg.<locals>.<genexpr>%  s+   è è € ÐWÐW¸#Õ0°Ñ5Ô5ÐWÐWÐWÐWÐWÐWr%   )rÍ   r¬   r³   rZ   ÚnextÚfilterr\   r!   s    r#   rÕ   rÕ     s‹   € Ý& qÑ)Ô)ð ØˆtÝ# AÑ&Ô&ð 
ØˆÝ	˜!Ñ	Ô	ð 
¥¨¡¤ð 
ÝÝ�4ÐWÐWÕASÐTUÑAVÔAVÐWÑWÔWÑXÔXØñ
ô 
ð 	
ð ˆ4r%   útuple[type, ...]c                ó    — t          | ¦  «        S r   )r   )r‰   s    r#   r\   r\   +  s   € å�NÑ#Ô#Ð#r%   Ú	some_typec                ó°   — t          | dt          | ¦  «        ¦  «        }t          | ¦  «        }|r&|dd                     d„ |D ¦   «         ¦  «        › d�z  }|S )NrC   ú[ú,c              3  ó4   K  — | ]}t          |¦  «        V — Œd S r   )Úget_type_name)r8   r<   s     r#   rÐ   z get_type_name.<locals>.<genexpr>4  s*   è è € ÐHÐH°A�}¨QÑ/Ô/ÐHÐHÐHÐHÐHÐHr%   ú])r(   r1   r\   Újoin)rÚ   Úresultra   s      r#   rß   rß   0  se   € Ý�Y 
­C°	©N¬NÑ;Ô;€FÝ'¨	Ñ2Ô2€NØð LØÐK�c—h’hÐHÐH¸ÐHÑHÔHÑHÔHÐKÐKÐKÑKˆØ€Mr%   ú	int | strc                ó2  — t          | ¦  «        rft          | ¦  «        }|sdS t          |¦  «        dk    r|d         t          u rdS d}|D ](}t	          |¦  «        st          |¦  «        r dS |dz  }Œ)|S t	          | ¦  «        rdS t          d| › �¦  «        ‚)záGets the value of 'nargs' appropriate for the given container type.

    Parameters
    ----------
    container_type : Type
        Some container type.

    Returns
    -------
    Union[int, str]
        [description]
    Ú*rµ   rÀ   r   z)Not sure what 'nargs' should be for type )r¥   r\   rÁ   rÂ   r£   ÚNotImplementedError)r‰   ra   Útotal_nargsÚ	item_types       r#   Úget_container_nargsré   8  sÑ   € õ �ÑÔð õ ,>¸nÑ+MÔ+MˆØð 	Ø�3Ýˆ~ÑÔ !Ò#Ð#¨°qÔ(9½XÐ(EÐ(EØ�3àˆØ'ð 	ð 	ˆIå�yÑ!Ô!ð ¥X¨iÑ%8Ô%8ð ð �s�sØ˜1ÑˆKˆKØÐåˆ~ÑÔð ØˆsÝ
ÐZÈ.ÐZÐZÑ
[Ô
[Ð[r%   FÚappend_actionúCallable[[str], list[Any]]c                óŒ   ‡ ‡‡‡— t          ‰ ¦  «        Št          ‰ ¦  «        rt          nt          } |¦   «         Šdˆˆˆ ˆfd„}|S )NÚvaluer1   c           	     óÎ   •— t                                d‰› d‰› d| › d�¦  «          t          ‰¦  «        | ¦  «        }t                                d|› d�¦  «         ‰r‰|z  Š‰S |S )Nzparsing multiple ú of ús, value is: 'rƒ   zparsing result is ')ÚloggerÚdebugÚ_parse_container)rí   Úvaluesr<   rê   r‰   râ   s     €€€€r#   Úparse_fnz,_parse_multiple_containers.<locals>.parse_fnq  sƒ   ø€ å�ŠÐV¨ÐVÐV¸QÐVÐVÈeÐVÐVÐVÑWÔWÐWØ1Õ! .Ñ1Ô1°%Ñ8Ô8ˆÝ�ŠÐ4¨6Ð4Ð4Ð4Ñ5Ô5Ð5àð 	Ø�fÑˆFØˆMàˆMr%   )rí   r1   )r—   r¥   r�   r�   )r‰   rê   Úfactoryrõ   r<   râ   s   ``  @@r#   Ú_parse_multiple_containersr÷   i  sj   øøøø€ õ 	(¨Ñ7Ô7€AÝ Ñ/Ô/Ð9�eˆeµT€GàˆW‰YŒY€Fð
ð 
ð 
ð 
ð 
ð 
ð 
ð 
ð 
ð €Or%   útype[Container]c                óº   ‡ ‡‡‡‡‡— t          ‰ ¦  «        Št          ‰ ¦  «        rt          nt          Šdd lŠdˆˆˆˆ fd„}dˆˆˆfd„Šdˆˆfd
„Š‰j        |_        |S )Nr   rí   r1   r   ú	list[Any]c           	     óH  •— t                                d‰› d‰› d| › d�¦  «         	  ‰| ¦  «        }nR# t          $ rE}t                                d| › dt          |¦  «        › d|› �¦  «          ‰| ¦  «        }Y d }~nd }~ww xY wt                                d|› �¦  «         |S )	Nz
Parsing a rï   rð   rƒ   z!Exception while trying to parse 'z' as a literal: z: zreturning values: )rñ   rò   Ú	Exceptionr    )rí   rô   Úer<   Ú_fallback_parseÚ_parse_literalr‰   s      €€€€r#   Ú_parsez _parse_container.<locals>._parse…  s×   ø€ Ý�ŠÐO .ÐOÐO°aÐOÐOÀuÐOÐOÐOÑPÔPÐPð	,Ø#�^ EÑ*Ô*ˆFˆFøÝð 	,ð 	,ð 	,Ý�LŠLÐb¸UÐbÐbÕTXÐYZÑT[ÔT[ÐbÐbÐ_`ÐbÐbÑcÔcÐcà$�_ UÑ+Ô+ˆFˆFˆFˆFˆFˆFøøøøð	,øøøõ 	�ŠÐ2¨&Ð2Ð2Ñ3Ô3Ð3Øˆs   §3 ³
B½;A=Á=Búlist[Any] | Anyc                óì   •— ‰                      | ¦  «        }t                               d|› �¦  «         t          |t          t
          f¦  «        s ‰|¦  «        S |} ‰ˆfd„|D ¦   «         ¦  «        }|S )zoTry to parse the string to a python expression directly.

        (useful for nested lists or tuples.)
        zParsed literal: c              3  ó.   •K  — | ]} ‰|¦  «        V — Œd S r   r6   )r8   r‡   r<   s     €r#   rÐ   z;_parse_container.<locals>._parse_literal.<locals>.<genexpr>   s+   øè è € Ð5Ð5 a˜Q˜Q˜q™TœTÐ5Ð5Ð5Ð5Ð5Ð5r%   )Úliteral_evalrñ   rò   r-   r�   r�   )rí   ÚliteralÚ	containerrô   r<   Úaströ   s       €€€r#   rÿ   z(_parse_container.<locals>._parse_literal“  s‡   ø€ ð
 ×"Ò" 5Ñ)Ô)ˆÝ�ŠÐ1¨Ð1Ð1Ñ2Ô2Ð2Ý˜'¥D­% =Ñ1Ô1ð 	ð �1�W‘:”:ÐàˆIØ�WÐ5Ð5Ð5Ð5¨9Ð5Ñ5Ô5Ñ5Ô5ˆFØˆMr%   r‡   c                ó\  •— d                      |                      ¦   «         ¦  «        } |                      d¦  «        r|                      d¦  «        r
| dd…         } d}dD ]}|| v r|}Œ	d„ |                      |¦  «        D ¦   «         }ˆfd„|D ¦   «         } ‰d	„ |D ¦   «         ¦  «        }|S )
Nú rÜ   rà   rÀ   éÿÿÿÿ)rÝ   c                ó6   — g | ]}|                      ¦   «         ‘ŒS r6   )r„   ©r8   r‡   s     r#   r:   z=_parse_container.<locals>._fallback_parse.<locals>.<listcomp>­  s    € Ð<Ð<Ð< A�a—g’g‘i”iÐ<Ð<Ð<r%   c                ó&   •— g | ]} ‰|¦  «        ‘ŒS r6   r6   )r8   Úv_strr<   s     €r#   r:   z=_parse_container.<locals>._fallback_parse.<locals>.<listcomp>®  s!   ø€ Ð5Ð5Ð5 �A�A�e‘H”HÐ5Ð5Ð5r%   c              3  ó   K  — | ]}|V — Œd S r   r6   r  s     r#   rÐ   z<_parse_container.<locals>._fallback_parse.<locals>.<genexpr>¯  s"   è è € Ð-Ð-˜q˜Ð-Ð-Ð-Ð-Ð-Ð-r%   )rá   ÚsplitÚ
startswithÚendswith)r‡   Ú	separatorÚsepÚ
str_valuesÚT_valuesrô   r<   rö   s         €€r#   rþ   z)_parse_container.<locals>._fallback_parse£  sÌ   ø€ Ø�HŠH�Q—W’W‘Y”YÑÔˆØ�<Š<˜ÑÔð 	 §¢¨C¡¤ð 	Ø�!�B�$”ˆAàˆ	Øð 	 ð 	 ˆCØ�aˆxˆxØ�	øà<Ð<¨¯ª°Ñ);Ô);Ð<Ñ<Ô<ˆ
Ø5Ð5Ð5Ð5¨*Ð5Ñ5Ô5ˆØ�Ð-Ð- HÐ-Ñ-Ô-Ñ-Ô-ˆØˆr%   )rí   r1   r   rú   )rí   r1   r   r  )r‡   r1   r   rú   )r—   r¥   r�   r�   r  rC   )r‰   r   r<   rþ   rÿ   r  rö   s   ` @@@@@r#   ró   ró   €  s¼   øøøøøø€ Ý'¨Ñ7Ô7€AÝ Ñ/Ô/Ð9�eˆeµT€GØ€J€J€Jðð ð ð ð ð ð ð ð ðð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ”j€F„OØ€Mr%   ÚobjectÚattribute_namerí   c                óâ   — d|vrt          | ||¦  «         d S |                     d¦  «        }t          | |d         ¦  «        }t          |d                     |dd …         ¦  «        |¦  «         d S )Nú.r   rÀ   )Úsetattrr  r(   Úsetattr_recursiverá   )rG   r  rí   ÚpartsÚchild_objects        r#   r  r  ¶  sw   € Ø
�.Ð Ð Ý��^ UÑ+Ô+Ð+Ð+Ð+à×$Ò$ SÑ)Ô)ˆÝ˜s E¨!¤HÑ-Ô-ˆÝ˜,¨¯ª°°q°r°r´Ñ(;Ô(;¸UÑCÔCÐCÐCÐCr%   c                óœ   — d|vrt          | |¦  «        S |                     d¦  «        \  }}}t          | |¦  «        }t          ||¦  «        S ©Nr  )r(   Ú	partitionÚgetattr_recursive)rG   r  Ú
child_attrÚ_Úrest_of_attribute_namer  s         r#   r"  r"  ¿  sX   € Ø
�.Ð Ð Ý�s˜NÑ+Ô+Ð+à0>×0HÒ0HÈÑ0MÔ0MÑ-ˆ
�AÐ-Ý˜s JÑ/Ô/ˆÝ  Ð/EÑFÔFÐFr%   Údestinationútuple[str, str]c                ó<   — |                       d¦  «        \  }}}||fS r   )Ú
rpartition)r&  Úparentr$  Úattribute_in_parents       r#   Ú
split_destr,  È  s)   € Ø%0×%;Ò%;¸CÑ%@Ô%@Ñ"€FˆAÐ"ØÐ&Ð&Ð&r%   c                ó    — t          | t          t          f¦  «        sdS t          | ¦  «        dk    rdS dt	          d„ | D ¦   «         ¦  «        z   S )Nr   rÀ   c              3  ó4   K  — | ]}t          |¦  «        V — Œd S r   )Úget_nesting_level)r8   Úitems     r#   rÐ   z$get_nesting_level.<locals>.<genexpr>Ó  s+   è è € ÐPÐP°4Õ(¨Ñ.Ô.ÐPÐPÐPÐPÐPÐPr%   )r-   r�   r�   rÁ   Úmax)Úpossibly_nested_lists    r#   r/  r/  Í  s[   € ÝÐ*­Tµ5¨MÑ:Ô:ð QØˆqÝ	Ð!Ñ	"Ô	" aÒ	'Ð	'Øˆqà•3ÐPÐPÐ;OÐPÑPÔPÑPÔPÑPÐPr%   údataclasses.FieldúT | _MISSING_TYPEc                ó–   — | j         t          j        ur| j         S | j        t          j        ur| j        } |¦   «         S t          j        S )aO  Returns the default value of a field in a dataclass, if available. When not available,
    returns `dataclasses.MISSING`.

    Args:
        field (dataclasses.Field): The dataclasses.Field to get the default value of.

    Returns:
        Union[T, _MISSING_TYPE]: The default value for that field, if present, or None otherwise.
    )ÚdefaultrJ   r   Údefault_factory)rW   Úconstructors     r#   Údefault_valuer9  Ö  sJ   € ð „}�KÔ/Ð/Ð/ØŒ}ÐØ	Ô	¥kÔ&9Ð	9Ð	9ØÔ+ˆØˆ{‰}Œ}ÐåÔ"Ð"r%   Ú	sentencesúlist[list[str]]údict[str, str | dict]c                óV  — t          t          ¦  «        }| D ]%}|d         }||                              |¦  «         Œ&i }|                     ¦   «         D ]U\  }} t	          | ¦  «        dk    rd                     | d         ¦  «        ||<   Œ7d„ | D ¦   «         }t          |¦  «        ||<   ŒV|S )aP  Given a list of sentences, creates a trie as a nested dicts of word strings.

    Args:
        sentences (List[List[str]]): a list of sentences

    Returns:
        Dict[str, Union[str, Dict[str, ...]]]: A tree where each node is a word in a sentence.
        Sentences which begin with the same words share the first nodes, etc.
    r   rÀ   r  c                ó"   — g | ]}|d d…         ‘ŒS )rÀ   Nr6   )r8   Úsentences     r#   r:   ztrie.<locals>.<listcomp>ý  s    € Ð+SÐ+SÐ+S¸X¨H°Q°R°R¬LÐ+SÐ+SÐ+Sr%   )r   r�   ÚappendÚitemsrÁ   rá   Útrie)r:  Úfirst_word_to_sentencesr?  Ú
first_wordÚreturn_dictÚsentences_without_first_words         r#   rB  rB  é  sÌ   € õ ;FÅdÑ:KÔ:KÐØð =ð =ˆØ˜a”[ˆ
Ø 
Ô+×2Ò2°8Ñ<Ô<Ð<Ð<à)+€KØ!8×!>Ò!>Ñ!@Ô!@ð Ið IÑˆ
�IÝˆy‰>Œ>˜QÒÐØ&)§h¢h¨y¸¬|Ñ&<Ô&<ˆK˜
Ñ#Ð#à+SÐ+SÈÐ+SÑ+SÔ+SÐ(Ý&*Ð+GÑ&HÔ&HˆK˜
Ñ#Ð#ØÐr%   r9   r�   Úkeys_to_keepúIterable[str]útuple[dict, dict]c                ó’   — t          |                      ¦   «         ¦  «        }i }|D ]}||vr|                      |¦  «        ||<   Œ| |fS )am  Removes all the keys in `d` that aren't in `keys`.

    Parameters
    ----------
    d : Dict
        Some dictionary.
    keys_to_keep : Iterable[str]
        The set of keys to keep

    Returns
    -------
    Tuple[Dict, Dict]
        The same dictionary (with all the unwanted keys removed) as well as a
        new dict containing only the removed item.
    )rŽ   ÚkeysÚpop)r9   rG  Úd_keysÚremovedÚkeys        r#   Ú	keep_keysrP    sT   € õ  �—’‘”‰]Œ]€FØ€GØð &ð &ˆØ�lÐ"Ð"ØŸ5š5 ™:œ:ˆG�C‰LøØˆgˆ:Ðr%   é   ÚsizeÚintc                óú  — t          j        ¦   «         }t          |                     ¦   «         ¦  «        D ]«\  }}|                     |                     d¦  «        ¦  «         t          |t          ¦  «        r4|                     t          | fi |¤Ž                     d¦  «        ¦  «         Œv|                     t          |¦  «                             d¦  «        ¦  «         Œ¬| 
                    ¦   «         d| …         S )z·Compute a unique hash out of a dictionary.

    Parameters
    ----------
    size: int
        size of the unique hash

    **sample:
        Dictionary to compute the hash from
    Úutf8N)ÚhashlibÚsha256ÚsortedrA  ÚupdateÚencoder-   r�   Úcompute_identityr1   Ú	hexdigest)rR  ÚsampleÚsample_hashÚkr‡   s        r#   r[  r[    sà   € õ ”.Ñ"Ô"€Kå�v—|’|‘~”~Ñ&Ô&ð 6ð 6‰ˆˆ1Ø×Ò˜1Ÿ8š8 FÑ+Ô+Ñ,Ô,Ð,å�a�ÑÔð 	6Ø×ÒÕ/°Ð:Ð:¸Ð:Ð:×AÒAÀ&ÑIÔIÑJÔJÐJÐJà×Ò�s 1™vœvŸ}š}¨VÑ4Ô4Ñ5Ô5Ð5Ð5à× Ò Ñ"Ô" 5 D 5Ô)Ð)r%   Údictsú
dict[K, V]ú!Iterable[tuple[K, tuple[V, ...]]]c               '  ó²   ‡K  — t          | d         ¦  «        }| D ]}|                     |¦  «         Œ|D ]!Š‰t          ˆfd„| D ¦   «         ¦  «        fV — Œ"d S )Nr   c              3  ó(   •K  — | ]}|‰         V — Œd S r   r6   ©r8   r9   rO  s     €r#   rÐ   z$dict_intersection.<locals>.<genexpr>7  s'   øè è € Ð0Ð0 Q˜!˜Cœ&Ð0Ð0Ð0Ð0Ð0Ð0r%   )rŽ   Úintersection_updater�   )r`  Úcommon_keysr9   rO  s      @r#   Údict_intersectionrh  2  s†   øè è € Ý�e˜A”h‘-”-€KØð +ð +ˆØ×'Ò'¨Ñ*Ô*Ð*Ð*Øð 2ð 2ˆØ•EÐ0Ð0Ð0Ð0¨%Ð0Ñ0Ô0Ñ0Ô0Ð1Ð1Ð1Ð1Ð1ð2ð 2r%   Ú	dataclassúdict[str, Field]c                ód   — t          ¦   «         }t          j        | ¦  «        D ]}|||j        <   Œ|S r   )r   rJ   Úfieldsrr   )ri  râ   rW   s      r#   Ú
field_dictrm  :  s9   € Ý*™}œ}€FÝÔ# IÑ.Ô.ð #ð #ˆØ"ˆˆuŒzÑÐØ€Mr%   ú(Iterable[tuple[K, tuple[V | None, ...]]]c               '  óŠ   ‡K  — t          t          j        | Ž ¦  «        }|D ]!Š‰t          ˆfd„| D ¦   «         ¦  «        fV — Œ"d S )Nc              3  óB   •K  — | ]}|                      ‰¦  «        V — Œd S r   )r`   re  s     €r#   rÐ   zzip_dicts.<locals>.<genexpr>F  s-   øè è € Ð4Ð4¨˜!Ÿ%š% ™*œ*Ð4Ð4Ð4Ð4Ð4Ð4r%   )rŽ   Ú	itertoolsÚchainr�   )r`  rK  rO  s     @r#   Ú	zip_dictsrs  A  sg   øè è € õ �yŒ Ð&Ñ'Ô'€DØð 6ð 6ˆØ•EÐ4Ð4Ð4Ð4¨eÐ4Ñ4Ô4Ñ4Ô4Ð5Ð5Ð5Ð5Ð5ð6ð 6r%   T©ÚrecurseÚdict_factoryru  c                ó”  ‡—  |¦   «         }‰s|S t          ‰¦  «        dk    sJ ‚t          ¦   «         } |j        ‰Ž  t          |¦  «        }ˆfd„|D ¦   «         }|D ]k\  }}g }d}	d}
|D ]6}t	          |t
          ¦  «        r| r|                     |¦  «         n|}	|
dz  }
Œ7t          |¦  «        |
k    r| rt          |d|dœŽ}	|	||<   Œl|S )aå  Simple dict union until we use python 3.9.

    If `recurse` is True, also does the union of nested dictionaries.
    NOTE: The returned dictionary has keys sorted alphabetically.
    >>> a = {'a': 1, 'b': 2, 'c': 3}
    >>> b = {'c': 5, 'd': 6, 'e': 7}
    >>> dict_union(a, b)
    {'a': 1, 'b': 2, 'c': 5, 'd': 6, 'e': 7}
    >>> a = {'a': 1, 'b': {'c': 2, 'd': 3}}
    >>> b = {'a': 2, 'b': {'c': 3, 'e': 6}}
    >>> dict_union(a, b)
    {'a': 2, 'b': {'c': 3, 'd': 3, 'e': 6}}
    rÀ   c              3  ó:   •‡K  — | ]Š‰ˆfd „‰D ¦   «         fV — ŒdS )c              3  ó0   •K  — | ]}‰|v ¯|‰         V — Œd S r   r6   )r8   r9   r_  s     €r#   rÐ   z'dict_union.<locals>.<genexpr>.<genexpr>a  s+   øè è € Ð+Ð+�a A¨ F FˆQˆqŒT F F F FÐ+Ð+r%   Nr6   )r8   r_  r`  s    @€r#   rÐ   zdict_union.<locals>.<genexpr>`  sO   øøè è € ð 3ð 3Ø12ˆÐ+Ð+Ð+Ð+˜5Ð+Ñ+Ô+Ð,ð3ð 3ð 3ð 3ð 3ð 3r%   Nr   Trt  )rÁ   rŽ   rY  rX  r-   r�   r@  Ú
dict_union)ru  rv  r`  râ   Úall_keysÚ
all_valuesr_  rô   Ú	sub_dictsÚ	new_valueÚn_valuesr‡   s     `         r#   rz  rz  I  s.  ø€ ð  �<‘>”>€FØð ØˆÝˆu‰:Œ:˜Š?ˆ?ˆ?ˆ?Ý™œ€HØ€H„O�UÐÐÝ�hÑÔ€Hð3ð 3ð 3ð 3Ø6>ð3ñ 3ô 3€Jð  ð ð ‰	ˆˆ6Ø "ˆ	Øˆ	ØˆØð 	ð 	ˆAÝ˜!�TÑ"Ô"ð  wð Ø× Ò  Ñ#Ô#Ð#Ð#ð �	Ø˜‰MˆHˆHåˆy‰>Œ>˜XÒ%Ð%¨'Ð%õ # I°tÈ,ÐWÐWÐWˆIàˆˆq‰	ˆ	Ø€Mr%   Únestedúdict[tuple[K, ...], V]c                óð   — i }|                       ¦   «         D ]^\  }}t          |t          j        ¦  «        r9t	          |¦  «                              ¦   «         D ]\  }}|g|¢R }||vsJ ‚|||<   ŒŒX|||f<   Œ_|S )zðFlatten a dictionary of dictionaries. The returned dictionary's keys are tuples, one entry
    per layer.

    >>> flatten({"a": {"b": 2, "c": 3}, "c": {"d": 3, "e": 4}})
    {('a', 'b'): 2, ('a', 'c'): 3, ('c', 'd'): 3, ('c', 'e'): 4}
    )rA  r-   r§   r	   Úflatten)r€  Ú	flattenedr_  r‡   ÚsubkeysÚsubvÚcollision_keys          r#   rƒ  rƒ  x  s¢   € ð )+€IØ—’‘”ð  ð  ‰ˆˆ1Ý�a�œÑ'Ô'ð 	 Ý!(¨¡¤×!1Ò!1Ñ!3Ô!3ð 0ð 0‘�˜Ø!"  W  �Ø$¨IÐ5Ð5Ð5Ð5Ø+/�	˜-Ñ(Ð(ð0ð
  ˆI�q�d‰OˆOØÐr%   r„  úMapping[tuple[K, ...], V]c                óú   — i }|                       ¦   «         D ]c\  }}|}|dd…         D ]/}t          |t          ¦  «        sJ ‚|                     |i ¦  «        }Œ0t          |t          ¦  «        sJ ‚|||d         <   Œd|S )zÇUnflatten a dictionary back into a possibly nested dictionary.

    >>> unflatten({('a', 'b'): 2, ('a', 'c'): 3, ('c', 'd'): 3, ('c', 'e'): 4})
    {'a': {'b': 2, 'c': 3}, 'c': {'d': 3, 'e': 4}}
    Nr
  )rA  r-   r�   Ú
setdefault)r„  r€  rK  rí   Úsub_dictionaryÚparts         r#   Ú	unflattenr�  ‹  s�   € ð (*€FØ —’Ñ(Ô(ð )ð )‰ˆˆeØˆØ˜˜"˜”Ið 	Að 	AˆDÝ˜n­dÑ3Ô3Ð3Ð3Ð3Ø+×6Ò6°t¸RÑ@Ô@ˆNˆNÝ˜.­$Ñ/Ô/Ð/Ð/Ð/Ø#(ˆ�t˜B”xÑ Ð Ø€Mr%   r  úPossiblyNestedMapping[str, V]r  údict[str, V]c                ó^   ‡— ˆfd„t          | ¦  «                             ¦   «         D ¦   «         S )aT  Flatten a dictionary of dictionaries. Joins different nesting levels with `sep` as
    separator.

    >>> flatten_join({'a': {'b': 2, 'c': 3}, 'c': {'d': 3, 'e': 4}})
    {'a.b': 2, 'a.c': 3, 'c.d': 3, 'c.e': 4}
    >>> flatten_join({'a': {'b': 2, 'c': 3}, 'c': {'d': 3, 'e': 4}}, sep="/")
    {'a/b': 2, 'a/c': 3, 'c/d': 3, 'c/e': 4}
    c                óB   •— i | ]\  }}‰                      |¦  «        |“ŒS r6   )rá   )r8   rK  rí   r  s      €r#   ú
<dictcomp>z flatten_join.<locals>.<dictcomp>¥  s)   ø€ ÐMÐMÐM¡k d¨EˆC�HŠH�T‰NŒN˜EÐMÐMÐMr%   )rƒ  rA  )r€  r  s    `r#   Úflatten_joinr“  œ  s2   ø€ ð NÐMÐMÐMµW¸V±_´_×5JÒ5JÑ5LÔ5LÐMÑMÔMÐMr%   úMapping[str, V]Ú	recursiveúPossiblyNestedDict[str, V]c                ó^   ‡— t          ˆfd„|                      ¦   «         D ¦   «         ¦  «        S )a«  Unflatten a dict into a possibly nested dict. Keys are split using `sep`.

    >>> unflatten_split({'a.b': 2, 'a.c': 3, 'c.d': 3, 'c.e': 4})
    {'a': {'b': 2, 'c': 3}, 'c': {'d': 3, 'e': 4}}

    >>> unflatten_split({'a': 2, 'b.c': 3})
    {'a': 2, 'b': {'c': 3}}

    NOTE: This function expects the input to be flat. It does *not* unflatten nested dicts:
    >>> unflatten_split({"a": {"b.c": 2}})
    {'a': {'b.c': 2}}
    c                ó\   •— i | ](\  }}t          |                     ‰¦  «        ¦  «        |“Œ)S r6   )r�   r  )r8   rO  rí   r  s      €r#   r’  z#unflatten_split.<locals>.<dictcomp>·  s1   ø€ ÐWÐWÐW±z°s¸E•e˜CŸIšI c™NœNÑ+Ô+¨UÐWÐWÐWr%   )r�  rA  )r„  r  r•  s    ` r#   Úunflatten_splitr™  ¨  s2   ø€ õ ÐWÐWÐWÐWÀYÇ_Â_ÑEVÔEVÐWÑWÔWÑXÔXÐXr%   rK  úIterable[K]c                ó   — d S r   r6   )r9   rK  s     r#   Úgetitem_recursiverœ  º  ó   € à€Cr%   r6  úV | Tc                ó   — d S r   r6   ©r9   rK  r6  s      r#   rœ  rœ  ¿  r�  r%   c                ó¸   — |t           ur0t          | ¦  «                             t          |¦  «        |¦  «        S t          | ¦  «        t          |¦  «                 S r   )r   rƒ  r`   r�   r   s      r#   rœ  rœ  Ä  sF   € ð •gÐÐÝ�q‰zŒz�~Š~�e D™kœk¨7Ñ3Ô3Ð3Ý�1‰:Œ:•e˜D‘k”kÔ"Ð"r%   útype[T]úset[type[T]]c                ól   — |                       ¦   «         } t          |¦  «        j        d„ |D ¦   «         Ž S )Nc                ó,   — g | ]}t          |¦  «        ‘ŒS r6   )Úall_subclasses)r8   Úss     r#   r:   z"all_subclasses.<locals>.<listcomp>Î  s    € Ð,]Ð,]Ð,]À1­^¸AÑ->Ô->Ð,]Ð,]Ð,]r%   )Ú__subclasses__rŽ   Úunion)r"   Úimmediate_subclassess     r#   r¦  r¦  Ì  s=   € Ø×+Ò+Ñ-Ô-ÐØ*�3Ð#Ñ$Ô$Ô*Ð,]Ð,]ÐH\Ð,]Ñ,]Ô,]Ð^Ð^r%   Ú__main__)r   r   )r   r+   )r0   r   r   r1   )rG   r   r   rH   )rG   r   r   rN   )rW   r   r   r   )r€   r�   r   r   )r‰   rŠ   r   r<   )r‰   rŠ   r   r’   )r"   r    r   r˜   )r"   r    r   r   )r"   r¾   r   r   )r"   r    r   rÒ   )r‰   r    r   rØ   )rÚ   r    )r‰   r    r   rã   )F)r‰   r    rê   r   r   rë   )r‰   rø   r   rë   )rG   r  r  r1   rí   r   )rG   r  r  r1   )r&  r1   r   r'  )rW   r3  r   r4  )r:  r;  r   r<  )r9   r�   rG  rH  r   rI  )rQ  )rR  rS  r   r1   )r`  ra  r   rb  )ri  rA   r   rj  )r`  ra  r   rn  )r`  ra  ru  r   r   ra  )r€  rV   r   r�  )r„  rˆ  r   rU   )r  )r€  rŽ  r  r1   r   r�  )r  F)r„  r”  r  r1   r•  r   r   r–  )r9   rU   rK  rš  r   r>   )r9   rU   rK  rš  r6  r<   r   rž  )r9   rU   rK  rš  r6  r4  r   rž  )r"   r¢  r   r£  )}rl   Ú
__future__r   r…   r7   rJ   r¯   rV  rP   rq  ro   rº   r¼   r.   Úcollectionsr   r   r   r§   Úcollections.abcr   r   r	   r
   r   r   r   r   Úloggingr   r   r   r   r   r   r   r   Útyping_extensionsr   r   r   r   r   r    ÚImportErrorr$   r*   r/   r4   rC   rñ   ÚdirÚbuiltin_typesr;   r<   r=   r>   r?   rA   rM   rR   rS   r   rS  Úfloatr1   ÚSimpleValueTyper�   r�   rŽ   ÚSimpleIterableÚPossiblyNestedDictÚPossiblyNestedMappingrb   ÚRuntimeErrorrd   rt   ry   rF   r   rˆ   r‘   r—   rž   r¡   r£   r¥   r¨   rª   r¬   r•   r±   r³   rZ   rÃ   r[   rÈ   rÊ   rÍ   rÕ   r\   rß   ré   r÷   ró   r  r"  r,  r/  r9  rB  rP  r[  rh  rm  rs  rz  rƒ  r�  r“  r™  rœ  r¦  ÚdoctestÚtestmodr6   r%   r#   ú<module>r¼     s8  ðØ LÐ LÐ LØ "Ð "Ð "Ð "Ð "Ð "à €€€Ø €€€Ø Ð Ð Ð Ø €€€Ø €€€Ø €€€Ø Ð Ð Ð Ø 	€	€	€	Ø 
€
€
€
Ø €€€Ø €€€Ø 0Ð 0Ð 0Ð 0Ð 0Ð 0Ð 0Ð 0Ø $Ð $Ð $Ð $Ð $Ð $Ø HÐ HÐ HÐ HÐ HÐ HÐ HÐ HÐ HÐ HÐ HÐ HØ 5Ð 5Ð 5Ð 5Ð 5Ð 5Ð 5Ð 5Ð 5Ð 5Ø Ð Ð Ð Ð Ð Ø Ð Ð Ð Ð Ð ðð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð QÐ PÐ PÐ PÐ PÐ PÐ PÐ PÐ PÐ PÐ PÐ PÐ PÐ PðØ,Ð,Ð,Ð,Ð,Ð,Ð,øØð ð ð Ø€J€J€Jðøøøð
ð ð ð ð9ð 9ð 9ð,ð ,ð ,ð ,ð*ð *ð *ð *ð 
ˆ�8Ñ	Ô	€ðð Ø"% # h¡-¤-ðñ ô €ð €GˆC�L„L€Ø€GˆC�L„L€Ø€GˆC�L„L€Ø€GˆC�L„L€Ø€GˆC�L„L€ð5ð 5ð 5ð 5ð 5�ñ 5ô 5ð 5ðQð Qð Qð QðBð Bð Bð Bð ˆW�\¨Ð3Ñ3Ô3€
à˜˜c 5¨#Ð-Ô.€Ø�t˜OÔ,¨d°3¸Ð3GÔ.HÈ#ÈoÔJ^Ð^Ô_€à˜!˜U 1Ð&@Ð#@ÔAÐAÔBÐ Ø  5¨Ð,IÐ)IÔ#JÐ JÔKÐ ð6ð 6ð 6ð 6ð*ð *ð *ð *ð * ñ *ô *ð *ð=ð =ð =ð
 9Ð8Ð8€Ð 8Ð 8Ð 8Ñ 8Ø9Ð9Ð9€Ð 9Ð 9Ð 9Ñ 9ð
ð 
ð 
ð 
ð <ð <ð <ð <ð~ð ð ð ð@ð ð ð ð2ð 2ð 2ð 2ð*ð ð ð ð>ð ð ð ð>"Að "Að "Að "AðJð ð ð ðBð ð ð ðð ð ð ðð ð ð ð%ð %ð %ð %ð1ð 1ð 1ð 1ð,$)ð $)ð $)ð $)ðNJð Jð Jð Jð#ð #ð #ð #ðLRð Rð Rð Rðð ð ð ð
ð 
ð 
ð 
ð$ð $ð $ð $ð
ð ð ð ð.\ð .\ð .\ð .\ðd 16ðð ð ð ð ð.3ð 3ð 3ð 3ðlDð Dð Dð DðGð Gð Gð Gð'ð 'ð 'ð 'ð
Qð Qð Qð#ð #ð #ð #ð&ð ð ð ð2ð ð ð ð0*ð *ð *ð *ð *ð02ð 2ð 2ð 2ðð ð ð ð6ð 6ð 6ð 6ð 48Àdð ,ð ,ð ,ð ,ð ,ð ,ð^ð ð ð ð&ð ð ð ð"	Nð 	Nð 	Nð 	Nð 	Nð CHðYð Yð Yð Yð Yð$ 
ðð ð ñ 
„ðð 
ðð ð ñ 
„ðð
 RYð#ð #ð #ð #ð #ð_ð _ð _ð _ð
 ˆzÒÐØ€N€N€Nà€G„OÑÔÐÐÐð Ðs   ÂB ÂBÂB