o

.��fS�@sH
dd
lZddl
mZ
ddlmZ
ddlmZmZmZm	Z	
ej
dkr(ddlmZ
nddlmZ
Gdd�de�Z
d	ed
e	e
deefdd
�Zd	edeedeedeedeef
dd�Z	
dd	edeedeeedeefdd�Zedkr�ddlmZ
eGdd�d��
Zeded
dd�ed
dd�ed
dd�g�Zeee�
�

d
Sd
S)�N)
�Fraction)
�ceil)�cast�List�Optional�Sequence)��)
�Protocolc@s:eZ
dZUd
ZdZeeed<dZeed<dZ	eed<dS)�Edgez1Any object that defines an edge (such as Layout).N�size�
�ratio�minimum_size)
�__name__�
__module__�__qualname__�__doc__rr�int�__annotations__rr�rr�6/usr/local/lib/python3.10/dist-packages/rich/_ratio.pyrs




r�total�edges�returncCs�d
d�|
D�
}t}d|vrtdd�t
t||
��
D�
}|tdd�|D�
�
}|dk
r2dd�t||
�D�
S||td	d�|D�
�
�}|D]\}}||j|jk
rS|j||<
nq@|d�
}	|D]\}}t||j|	d
�\}
}	|
||<qZnd|vs
ttt	|�S)a�Divide total space to satisfy size, ratio, and minimum_size, constraints.

    The returned list of integers should add up to total in most cases, unless it is
    impossible to satisfy all the constraints. For instance, if there are two edges
    with a minimum size of 20 each and `total` is 30 then the returned list will be
    greater than total. In practice, this would mean that a Layout object would
    clip the rows that would overflow the screen height.

    Args:
        total (int): Total number of characters.
        edges (List[Edge]): Edges within total space.

    Returns:
        List[int]: Number of characters for each edge.
    c
Ssg|]}
|
jpd�qS�
N)
r)�.0�edgerrr�
<listcomp>%sz!ratio_resolve.<locals>.<listcomp>Nc
Ss$g|]\}
\}}|dur|
|f�qSrr)r�indexrrrrrr,s


�c
ss�|]}
|
pdV
qd
S)r
Nr)rrrrr�	<genexpr>2s�z ratio_resolve.<locals>.<genexpr>r
c
Ss&g|]\}
}|
dur|jpd
n
|
�qS)Nr
)
r)rrrrrrr5s���c
ss�|]
\}
}|jp
dV
qd
S)r
N)
r)r�
_rrrrr ;s�r
)
r�	enumerate�zip�sumrr�divmodrrr)rr�sizes�	_Fraction�flexible_edges�	remaining�portionrr�	remainderrrrr�
ratio_resolves4�
�
�


�




�$r,�ratios�maximums�valuescCs�d
d�t|
|�D�
}
t
|
�
}|s|dd�S|}g}|j}t|
||�D])\}}	}
|rH|dkrHt|	t|||�
�}||
|�

||8}||8}q#||
�

q#|S)ad
Divide an integer total in to parts based on ratios.

    Args:
        total (int): The total to divide.
        ratios (List[int]): A list of integer ratios.
        maximums (List[int]): List of maximums values for each slot.
        values (List[int]): List of values

    Returns:
        List[int]: A list of integers guaranteed to sum to total.
    c
S�g|]
\}
}|r
|
n
d�qS�
r
r)rr�_maxrrrr_�z ratio_reduce.<locals>.<listcomp>Nr
)r#r$�append�min�round)rr-r.r/�total_ratio�total_remaining�resultr4r�maximum�value�distributedrrr�ratio_reduceQs














r=�minimumscCs�|rd
d�t|
|�D�
}
t
|
�
}|dksJd�
�
|}g}|j}|dur+dg
t|
�
}n|}t|
|�D]"\}}	|dkrFt|	t|||�
�}
n|}
||
�

||8}||
8}q2|S)a<
Distribute an integer total in to parts based on ratios.

    Args:
        total (int): The total to divide.
        ratios (List[int]): A list of integer ratios.
        minimums (List[int]): List of minimum values for each slot.

    Returns:
        List[int]: A list of integers guaranteed to sum to total.
    c
Sr0r1r)rr�_minrrrrr3z$ratio_distribute.<locals>.<listcomp>r
zSum of ratios must be > 0N)r#r$r4�len�maxr)rr-r>r7r8�distributed_totalr4�	_minimumsr�minimumr<rrr�ratio_distributeqs$















rE�__main__)
�	dataclassc@s6eZ
dZUd
Zeeed<dZeed<dZeed<d
S)�
ENrr
rr)	rrrrrrrrrrrrrrH�s


rH�nr
r)�sys�	fractionsr�mathr�typingrrrr�version_infor
�typing_extensionsrrr,r=rEr�dataclassesrGrH�resolved�printr$rrrr�<module>
sJ




=
�
�
�
�
�!�
�
�

�
�$

(
�