a
    ¥Q•h~W  ã                   @   sÜ   d Z g d¢ZddlmZ ddlmZ dd„ Zdd	„ Zd!dd„Zd"dd„Z	dd„ Z
d#dd„Zd$ddœdd„Zd%dd„ZG dd„ deƒZdd„ Zd&dd„Zed krØdd
lZdd
lZeejƒdkrÈe eƒ ¡ e e ¡ j¡ d
S )'z%Variation fonts interpolation models.)ÚnormalizeValueÚnormalizeLocationÚsupportScalarÚpiecewiseLinearMapÚVariationModelé    )ÚnoRoundé   )ÚVariationModelErrorc                 C   s   dd„ | D ƒS )Nc                 S   s   g | ]}|d ur|‘qS ©N© ©Ú.0Úlr   r   úP/var/www/sistema_ama/venv/lib/python3.9/site-packages/fontTools/varLib/models.pyÚ
<listcomp>   ó    znonNone.<locals>.<listcomp>r   ©Úlstr   r   r   ÚnonNone   s    r   c                 C   s   t dd„ | D ƒƒS )Nc                 s   s   | ]}|d u V  qd S r
   r   r   r   r   r   Ú	<genexpr>   r   zallNone.<locals>.<genexpr>©Úallr   r   r   r   ÚallNone   s    r   Nc                    s>   ˆd u rt ‡fdd„|D ƒƒS ˆˆƒ‰ t ‡ ‡fdd„|D ƒƒS )Nc                 3   s   | ]}ˆ |kV  qd S r
   r   ©r   Úitem)Úrefr   r   r      r   zallEqualTo.<locals>.<genexpr>c                 3   s   | ]}ˆ ˆ|ƒkV  qd S r
   r   r   )ÚmappedÚmapperr   r   r      r   r   )r   r   r   r   )r   r   r   r   Ú
allEqualTo   s    r   c                 C   s@   | sdS t | ƒ}zt|ƒ}W n ty0   Y dS 0 t|||d�S )NT)r   )ÚiterÚnextÚStopIterationr   )r   r   ÚitÚfirstr   r   r   ÚallEqual   s    r$   c                 C   s(   t | ƒt |ƒksJ ‚dd„ t|| ƒD ƒS )Nc                 S   s   g | ]\}}|r|‘qS r   r   )r   r   Útr   r   r   r   ,   r   zsubList.<locals>.<listcomp>©ÚlenÚzip)Útruthr   r   r   r   ÚsubList*   s    r*   Fc              
   C   sî   |\}}}||  kr|ks@n t d|d›d|d›d|d›�ƒ‚|sTtt| |ƒ|ƒ} | |ksd||krhdS | |k rx||ksˆ| |kr˜||kr˜| | ||  S | |kr¨||ksÚ| |k r¸||ksÚJ d| › d|› d|› d|› d�	ƒ‚| | ||  S dS )	zÙNormalizes value based on a min/default/max triple.

    >>> normalizeValue(400, (100, 400, 900))
    0.0
    >>> normalizeValue(100, (100, 400, 900))
    -1.0
    >>> normalizeValue(650, (100, 400, 900))
    0.5
    z8Invalid axis values, must be minimum, default, maximum: z3.3fz, ç        zOoops... v=z
, triple=(ú)N)Ú
ValueErrorÚmaxÚmin)ÚvÚtripleÚextrapolateÚlowerÚdefaultÚupperr   r   r   r   /   s2    

ÿÿÿÿ ÿÿþr   )Úvalidatec                C   st   |r8t |  ¡ ƒt | ¡ ƒks8J t |  ¡ ƒt | ¡ ƒ ƒ‚i }| ¡ D ]*\}}|  ||d ¡}t|||d�||< qD|S )aÓ  Normalizes location based on axis min/default/max values from axes.

    >>> axes = {"wght": (100, 400, 900)}
    >>> normalizeLocation({"wght": 400}, axes)
    {'wght': 0.0}
    >>> normalizeLocation({"wght": 100}, axes)
    {'wght': -1.0}
    >>> normalizeLocation({"wght": 900}, axes)
    {'wght': 1.0}
    >>> normalizeLocation({"wght": 650}, axes)
    {'wght': 0.5}
    >>> normalizeLocation({"wght": 1000}, axes)
    {'wght': 1.0}
    >>> normalizeLocation({"wght": 0}, axes)
    {'wght': -1.0}
    >>> axes = {"wght": (0, 0, 1000)}
    >>> normalizeLocation({"wght": 0}, axes)
    {'wght': 0.0}
    >>> normalizeLocation({"wght": -1}, axes)
    {'wght': 0.0}
    >>> normalizeLocation({"wght": 1000}, axes)
    {'wght': 1.0}
    >>> normalizeLocation({"wght": 500}, axes)
    {'wght': 0.5}
    >>> normalizeLocation({"wght": 1001}, axes)
    {'wght': 1.0}
    >>> axes = {"wght": (0, 1000, 1000)}
    >>> normalizeLocation({"wght": 0}, axes)
    {'wght': -1.0}
    >>> normalizeLocation({"wght": -1}, axes)
    {'wght': -1.0}
    >>> normalizeLocation({"wght": 500}, axes)
    {'wght': -0.5}
    >>> normalizeLocation({"wght": 1000}, axes)
    {'wght': 0.0}
    >>> normalizeLocation({"wght": 1001}, axes)
    {'wght': 0.0}
    r   )r2   )ÚsetÚkeysÚitemsÚgetr   )ÚlocationÚaxesr2   r6   ÚoutÚtagr1   r0   r   r   r   r   N   s    '&ÿr   Tc                 C   s°  |r|du rt dƒ‚d}| ¡ D �]ˆ\}\}}}	|rp|dkr>q ||ks ||	krPq |dk rb|	dkrbq |  |d¡}
n|| v s|J ‚| | }
|
|krŽq |�rX|| \}}|
|k rø||krø||krØ||	k rØ||
|	 ||	  9 }q n||k rö||
| ||  9 }q n`||
k �rX||	k�rX||k�r8||k �r8||
| ||  9 }q n ||k �rX||
|	 ||	  9 }q |
|k�sl|	|
k�rvd} �q¬|
|k �r–||
| ||  9 }q ||
|	 ||	  9 }q |S )a‡  Returns the scalar multiplier at location, for a master
    with support.  If ot is True, then a peak value of zero
    for support of an axis means "axis does not participate".  That
    is how OpenType Variation Font technology works.

    If extrapolate is True, axisRanges must be a dict that maps axis
    names to (axisMin, axisMax) tuples.

      >>> supportScalar({}, {})
      1.0
      >>> supportScalar({'wght':.2}, {})
      1.0
      >>> supportScalar({'wght':.2}, {'wght':(0,2,3)})
      0.1
      >>> supportScalar({'wght':2.5}, {'wght':(0,2,4)})
      0.75
      >>> supportScalar({'wght':2.5, 'wdth':0}, {'wght':(0,2,4), 'wdth':(-1,0,+1)})
      0.75
      >>> supportScalar({'wght':2.5, 'wdth':.5}, {'wght':(0,2,4), 'wdth':(-1,0,+1)}, ot=False)
      0.375
      >>> supportScalar({'wght':2.5, 'wdth':0}, {'wght':(0,2,4), 'wdth':(-1,0,+1)})
      0.75
      >>> supportScalar({'wght':2.5, 'wdth':.5}, {'wght':(0,2,4), 'wdth':(-1,0,+1)})
      0.75
      >>> supportScalar({'wght':3}, {'wght':(0,1,2)}, extrapolate=True, axisRanges={'wght':(0, 2)})
      -1.0
      >>> supportScalar({'wght':-1}, {'wght':(0,1,2)}, extrapolate=True, axisRanges={'wght':(0, 2)})
      -1.0
      >>> supportScalar({'wght':3}, {'wght':(0,2,2)}, extrapolate=True, axisRanges={'wght':(0, 2)})
      1.5
      >>> supportScalar({'wght':-1}, {'wght':(0,2,2)}, extrapolate=True, axisRanges={'wght':(0, 2)})
      -0.5
    Nz2axisRanges must be passed when extrapolate is Trueg      ð?r+   )Ú	TypeErrorr9   r:   )r;   ÚsupportÚotr2   Ú
axisRangesÚscalarÚaxisr3   Úpeakr5   r0   ÚaxisMinÚaxisMaxr   r   r   r   €   sN    "

r   c                   @   sÌ   e Zd ZdZd(ddœdd„Zdd„ Zed	d
„ ƒZeg fdd„ƒZdd„ Z	dd„ Z
dd„ Zdd„ Zedœdd„Zedœdd„Zdd„ Zdd„ Zedd„ ƒZed d!„ ƒZd"d#„ Zedœd$d%„Zedœd&d'„ZdS ))r   a5  Locations must have the base master at the origin (ie. 0).

    If axis-ranges are not provided, values are assumed to be normalized to
    the range [-1, 1].

    If the extrapolate argument is set to True, then values are extrapolated
    outside the axis range.

      >>> from pprint import pprint
      >>> axisRanges = {'wght': (-180, +180), 'wdth': (-1, +1)}
      >>> locations = [       {'wght':100},       {'wght':-100},       {'wght':-180},       {'wdth':+.3},       {'wght':+120,'wdth':.3},       {'wght':+120,'wdth':.2},       {},       {'wght':+180,'wdth':.3},       {'wght':+180},       ]
      >>> model = VariationModel(locations, axisOrder=['wght'], axisRanges=axisRanges)
      >>> pprint(model.locations)
      [{},
       {'wght': -100},
       {'wght': -180},
       {'wght': 100},
       {'wght': 180},
       {'wdth': 0.3},
       {'wdth': 0.3, 'wght': 180},
       {'wdth': 0.3, 'wght': 120},
       {'wdth': 0.2, 'wght': 120}]
      >>> pprint(model.deltaWeights)
      [{},
       {0: 1.0},
       {0: 1.0},
       {0: 1.0},
       {0: 1.0},
       {0: 1.0},
       {0: 1.0, 4: 1.0, 5: 1.0},
       {0: 1.0, 3: 0.75, 4: 0.25, 5: 1.0, 6: 0.6666666666666666},
       {0: 1.0,
        3: 0.75,
        4: 0.25,
        5: 0.6666666666666667,
        6: 0.4444444444444445,
        7: 0.6666666666666667}]
    NF)rB   c                   sæ   t tdd„ ˆ D ƒƒƒt ˆ ƒkr&tdƒ‚ˆ ˆ_|d ur8|ng ˆ_|ˆ_|d u rx|r\ˆ ˆ ¡}ndd„ ˆ D ƒ}dd„ |D ƒ}|ˆ_dd	„ ˆ D ƒ‰ ˆjˆ ˆjd
�}t	ˆ |d�ˆ_
‡fdd	„ˆ D ƒˆ_‡ fdd	„ˆj
D ƒˆ_ˆ ¡  i ˆ_d S )Nc                 s   s   | ]}t t| ¡ ƒƒV  qd S r
   )ÚtupleÚsortedr9   r   r   r   r   r     r   z*VariationModel.__init__.<locals>.<genexpr>zLocations must be unique.c                 S   s   h | ]}|  ¡ D ]}|’qqS r   ©r8   ©r   ÚlocrD   r   r   r   Ú	<setcomp>  r   z*VariationModel.__init__.<locals>.<setcomp>c                 S   s   i | ]
}|d “qS ))éÿÿÿÿr   r   ©r   rD   r   r   r   Ú
<dictcomp>  r   z+VariationModel.__init__.<locals>.<dictcomp>c                 S   s   g | ]}d d„ |  ¡ D ƒ‘qS )c                 S   s   i | ]\}}|d kr||“qS ©r+   r   ©r   Úkr0   r   r   r   rP     r   z6VariationModel.__init__.<locals>.<listcomp>.<dictcomp>©r9   ©r   rL   r   r   r   r     r   z+VariationModel.__init__.<locals>.<listcomp>©Ú	axisOrder)Úkeyc                    s   g | ]}ˆ j  |¡‘qS r   ©Ú	locationsÚindexr   ©Úselfr   r   r     r   c                    s   g | ]}ˆ   |¡‘qS r   ©r[   r   ©rZ   r   r   r     r   )r'   r7   r	   ÚorigLocationsrW   r2   ÚcomputeAxisRangesrB   ÚgetMasterLocationsSortKeyFuncrI   rZ   ÚmappingÚreverseMappingÚ_computeMasterSupportsÚ
_subModels)r]   rZ   rW   r2   rB   ÚallAxesZkeyFuncr   )rZ   r]   r   Ú__init__  s(    ÿzVariationModel.__init__c                 C   sb   d|vr| |fS t dd„ |D ƒƒ}| j |¡}|du rTtt|| jƒ| jƒ}|| j|< |t||ƒfS )zºReturn a sub-model and the items that are not None.

        The sub-model is necessary for working with the subset
        of items when some are None.

        The sub-model is cached.Nc                 s   s   | ]}|d uV  qd S r
   r   ©r   r0   r   r   r   r   *  r   z-VariationModel.getSubModel.<locals>.<genexpr>)rH   rf   r:   r   r*   r`   rW   )r]   r9   rX   ZsubModelr   r   r   ÚgetSubModel!  s    
zVariationModel.getSubModelc                 C   sb   i }dd„ | D ƒ}| D ]F}|D ]<}|  |d¡}|  |||f¡\}}t||ƒt||ƒf||< qq|S )Nc                 S   s   h | ]}|  ¡ D ]}|’qqS r   rJ   rK   r   r   r   rM   4  r   z3VariationModel.computeAxisRanges.<locals>.<setcomp>r   )r:   r/   r.   )rZ   rB   rg   rL   rD   ÚvaluerF   rG   r   r   r   ra   1  s    z VariationModel.computeAxisRangesc                 C   s”   i | vrt dƒ‚i }| D ]d}t|ƒdkr*qtt|ƒƒ}|| }||vrPdh||< ||| vsnJ d|||f ƒ‚||  |¡ qdd„ }|||ƒ}|S )NzBase master not found.r   r+   z&Value "%s" in axisPoints["%s"] -->  %sc                    s   dd„ ‰‡ ‡‡fdd„}|S )Nc                 S   s   | dk rdS | dkrdS dS )Nr   rN   r   r   ©r0   r   r   r   ÚsignN  s    zJVariationModel.getMasterLocationsSortKeyFunc.<locals>.getKey.<locals>.signc              	      s¢   t ˆ ƒ}‡fdd„ˆ  ¡ D ƒ}‡ fdd„ˆD ƒ}| ‡fdd„tˆ  ¡ ƒD ƒ¡ |t |ƒ t‡fdd„|D ƒƒt|ƒt‡ ‡fdd„|D ƒƒt‡ fdd„|D ƒƒfS )	Nc                    s(   g | ] \}}|ˆ v r|ˆ | v r|‘qS r   r   )r   rD   rk   )Ú
axisPointsr   r   r   S  s   þz]VariationModel.getMasterLocationsSortKeyFunc.<locals>.getKey.<locals>.key.<locals>.<listcomp>c                    s   g | ]}|ˆ v r|‘qS r   r   rO   ©rL   r   r   r   X  r   c                    s   g | ]}|ˆ vr|‘qS r   r   rO   rV   r   r   r   Z  r   c                 3   s$   | ]}|ˆ v rˆ   |¡nd V  qdS )i   Nr^   rO   rV   r   r   r   _  s   ÿz\VariationModel.getMasterLocationsSortKeyFunc.<locals>.getKey.<locals>.key.<locals>.<genexpr>c                 3   s   | ]}ˆˆ | ƒV  qd S r
   r   rO   )rL   rm   r   r   r   d  s   c                 3   s   | ]}t ˆ | ƒV  qd S r
   )ÚabsrO   ro   r   r   r   g  s   )r'   r9   ÚextendrI   r8   rH   )rL   ZrankZonPointAxesZorderedAxes©rW   rn   rm   ro   r   rX   Q  s*    
þÿþÿÿõzIVariationModel.getMasterLocationsSortKeyFunc.<locals>.getKey.<locals>.keyr   )rn   rW   rX   r   rr   r   ÚgetKeyM  s    z<VariationModel.getMasterLocationsSortKeyFunc.<locals>.getKey)r	   r'   r    r   Úadd)rZ   rW   rn   rL   rD   rk   rs   Úretr   r   r   rb   <  s$    

ÿþ!
z,VariationModel.getMasterLocationsSortKeyFuncc                    sj   ‡fdd„|D ƒ}‡fdd„|D ƒˆ_ dd„ ˆj D ƒ‰ ‡fdd„ˆ D ƒˆ_‡ fdd„ˆjD ƒˆ_i ˆ_|S )Nc                    s   g | ]}ˆ | ‘qS r   r   ©r   Úidx)Úmaster_listr   r   r   t  r   z1VariationModel.reorderMasters.<locals>.<listcomp>c                    s   g | ]}ˆ j | ‘qS r   )r`   rv   r\   r   r   r   u  r   c                 S   s   g | ]}d d„ |  ¡ D ƒ‘qS )c                 S   s   i | ]\}}|d kr||“qS rQ   r   rR   r   r   r   rP   w  r   z<VariationModel.reorderMasters.<locals>.<listcomp>.<dictcomp>rT   rU   r   r   r   r   v  s   c                    s   g | ]}ˆ j  |¡‘qS r   rY   r   r\   r   r   r   y  r   c                    s   g | ]}ˆ   |¡‘qS r   r^   r   r_   r   r   r   z  r   )r`   rc   rZ   rd   rf   )r]   rx   rc   Znew_listr   )rZ   rx   r]   r   ÚreorderMastersq  s    ÿzVariationModel.reorderMastersc                 C   sŽ  g | _ |  ¡ }t|ƒD �]h\}}t| ¡ ƒ}|d |… D �]8}t| ¡ ƒ|krPq8d}| ¡ D ]D\}\}}	}
|| d |	ks\||| d   k r–|
k s\n d} q¢q\|s¨q8i }d}| ¡ D ]œ}|| d }||v sÔJ ‚|| \}}}
||
 }}||k �r|}|| ||  }n ||k r¸|}|| |
|  }nq¸||k�r>i }|}||kr¸|||f||< q¸| ¡ D ]\}}|||< �q^q8| j  |¡ q|  ¡  d S )NTr   FrN   )ÚsupportsÚ_locationsToRegionsÚ	enumerater7   r8   r9   ÚappendÚ_computeDeltaWeights)r]   ÚregionsÚiÚregionZlocAxesZprev_regionZrelevantrD   r3   rE   r5   ZbestAxesZ	bestRatioÚvalÚlocVZnewLowerZnewUpperÚratior1   r   r   r   re   ~  sT    ÿþþ	


z%VariationModel._computeMasterSupportsc                 C   st   | j }| j}g }|D ]Z}i }| ¡ D ]>\}}|dkrLd||| d f||< q$|| d |df||< q$| |¡ q|S )Nr   r   )rZ   rB   r9   r}   )r]   rZ   rB   r   rL   r�   rD   rƒ   r   r   r   r{   ¶  s    z"VariationModel._locationsToRegionsc                 C   s`   g | _ t| jƒD ]J\}}i }t| jd |… ƒD ]\}}t||ƒ}|r.|||< q.| j  |¡ qd S r
   )ÚdeltaWeightsr|   rZ   rz   r   r}   )r]   r€   rL   ZdeltaWeightÚjr@   rC   r   r   r   r~   Å  s    

z#VariationModel._computeDeltaWeights©Úroundc          
      C   sœ   t |ƒt | jƒks(J t |ƒt | jƒfƒ‚| j}g }t| jƒD ]Z\}}|||  }| ¡ D ].\}}	|	dkrv||| 8 }qX||| |	 8 }qX| ||ƒ¡ q<|S )Nr   )r'   r…   rd   r|   r9   r}   )
r]   ÚmasterValuesrˆ   rc   r=   r€   ÚweightsÚdeltar†   Úweightr   r   r   Ú	getDeltasÐ  s    þzVariationModel.getDeltasc                C   s"   |   |¡\}}|j||d�|jfS )Nr‡   )rj   r�   rz   )r]   r9   rˆ   Úmodelr   r   r   ÚgetDeltasAndSupportsá  s    z#VariationModel.getDeltasAndSupportsc                    s   ‡ ‡fdd„ˆj D ƒS )zûReturn scalars for each delta, for the given location.
        If interpolating many master-values at the same location,
        this function allows speed up by fetching the scalars once
        and using them with interpolateFromMastersAndScalars().c                    s    g | ]}t ˆ |ˆjˆjd �‘qS ))r2   rB   )r   r2   rB   )r   r@   ©rL   r]   r   r   r   ê  s   ýÿz-VariationModel.getScalars.<locals>.<listcomp>)rz   )r]   rL   r   r�   r   Ú
getScalarså  s    üzVariationModel.getScalarsc                    sp   ˆ  |¡‰ tttˆjƒƒƒD ]2\}}| ¡ D ] \}}ˆ |  ˆ | | 8  < q,q‡ ‡fdd„ttˆ ƒƒD ƒ‰ ˆ S )a­  Return multipliers for each master, for the given location.
        If interpolating many master-values at the same location,
        this function allows speed up by fetching the scalars once
        and using them with interpolateFromValuesAndScalars().

        Note that the scalars used in interpolateFromMastersAndScalars(),
        are *not* the same as the ones returned here. They are the result
        of getScalars().c                    s   g | ]}ˆ ˆj |  ‘qS r   )rc   )r   r€   ©r=   r]   r   r   r   ÿ  r   z3VariationModel.getMasterScalars.<locals>.<listcomp>)r‘   ÚreversedÚlistr|   r…   r9   Úranger'   )r]   ZtargetLocationr€   rŠ   r†   rŒ   r   r’   r   ÚgetMasterScalarsñ  s    	
zVariationModel.getMasterScalarsc                 C   sT   d}t | ƒt |ƒksJ ‚t| |ƒD ],\}}|s0q"|| }|du rF|}q"||7 }q"|S )aV  Interpolate from values and scalars coefficients.

        If the values are master-values, then the scalars should be
        fetched from getMasterScalars().

        If the values are deltas, then the scalars should be fetched
        from getScalars(); in which case this is the same as
        interpolateFromDeltasAndScalars().
        Nr&   )ÚvaluesÚscalarsr0   rk   rC   Zcontributionr   r   r   ÚinterpolateFromValuesAndScalars  s    
z.VariationModel.interpolateFromValuesAndScalarsc                 C   s   t  | |¡S )z>Interpolate from deltas and scalars fetched from getScalars().)r   r™   )Údeltasr˜   r   r   r   ÚinterpolateFromDeltasAndScalars  s    z.VariationModel.interpolateFromDeltasAndScalarsc                 C   s   |   |¡}|  ||¡S )z)Interpolate from deltas, at location loc.)r‘   r›   )r]   rL   rš   r˜   r   r   r   ÚinterpolateFromDeltas  s    
z$VariationModel.interpolateFromDeltasc                C   s   |   |¡}|  ||¡S )z0Interpolate from master-values, at location loc.)r–   r™   )r]   rL   r‰   rˆ   r˜   r   r   r   ÚinterpolateFromMasters#  s    
z%VariationModel.interpolateFromMastersc                C   s   | j ||d�}|  ||¡S )z²Interpolate from master-values, and scalars fetched from
        getScalars(), which is useful when you want to interpolate
        multiple master-values with the same location.r‡   )r�   r›   )r]   r‰   r˜   rˆ   rš   r   r   r   Ú interpolateFromMastersAndScalars(  s    z/VariationModel.interpolateFromMastersAndScalars)NF)Ú__name__Ú
__module__Ú__qualname__Ú__doc__rh   rj   Ústaticmethodra   rb   ry   re   r{   r~   r   r�   r�   r‘   r–   r™   r›   rœ   r�   rž   r   r   r   r   r   Ñ   s2   2 ÿÿ

48

r   c                    s¸   |  ¡ }|sˆ S ˆ |v r |ˆ  S t|ƒ}ˆ |k r@ˆ ||  | S t|ƒ}ˆ |kr`ˆ ||  | S t‡ fdd„|D ƒƒ}t‡ fdd„|D ƒƒ}|| }|| }||| ˆ |  ||   S )Nc                 3   s   | ]}|ˆ k r|V  qd S r
   r   ©r   rS   rl   r   r   r   =  r   z%piecewiseLinearMap.<locals>.<genexpr>c                 3   s   | ]}|ˆ kr|V  qd S r
   r   r¤   rl   r   r   r   >  r   )r8   r/   r.   )r0   rc   r8   rS   ÚaÚbÚvaZvbr   rl   r   r   0  s     r   c           
         s\  ddl m} ddl}|jdtjd�}|jdddd	d
� |jdd�}|jdddtd� |jdddddd� | 	| ¡} || j
d� ddlm} | jrøddlm} |ƒ }| | j¡ dd„ |jD ƒ}tdƒ ||ƒ | ¡  tdƒ dd„ |jD ƒ}||ƒ n4dd„ ttd ƒtd!ƒd" ƒD ƒ‰ ‡ fd#d„| jD ƒ}t|ƒ}	td$ƒ ||	jƒ td%ƒ ||	jƒ dS )&z*Normalize locations on a given designspacer   )ÚconfigLoggerNzfonttools varLib.models)Údescriptionz
--loglevelÚLEVELÚINFOz Logging level (defaults to INFO))Úmetavarr4   ÚhelpT)Úrequiredz-dz--designspaceZDESIGNSPACE)r¬   Útypez-lz--locationsÚLOCATIONú+zFMaster locations as comma-separate coordinates. One must be all zeros.)r¬   Únargsr­   )Úlevel)Úpprint)ÚDesignSpaceDocumentc                 S   s   g | ]
}|j ‘qS r   ©r;   ©r   Úsr   r   r   r   h  r   zmain.<locals>.<listcomp>zOriginal locations:zNormalized locations:c                 S   s   g | ]
}|j ‘qS r   r¶   r·   r   r   r   r   m  r   c                 S   s   g | ]}t |ƒ‘qS r   )Úchr)r   Úcr   r   r   r   p  r   ÚAÚZr   c              	      s*   g | ]"}t tˆ d d„ | d¡D ƒƒƒ‘qS )c                 s   s   | ]}t |ƒV  qd S r
   )Úfloatri   r   r   r   r   r  r   z"main.<locals>.<listcomp>.<genexpr>ú,)Údictr(   Úsplitr·   ©r<   r   r   r   q  s   zSorted locations:z	Supports:)Ú	fontToolsr¨   ÚargparseÚArgumentParserÚmainr¢   Úadd_argumentÚadd_mutually_exclusive_groupÚstrÚ
parse_argsZloglevelr´   ÚdesignspaceÚfontTools.designspaceLibrµ   ÚreadÚsourcesÚprintÚ	normalizer•   ÚordrZ   r   rz   )
Úargsr¨   rÃ   ÚparserÚgroupr´   rµ   ÚdocZlocsrŽ   r   rÁ   r   rÅ   D  sX    þüû

 
ÿ
rÅ   Ú__main__)N)N)F)F)TFN)N)r¢   Ú__all__ÚfontTools.misc.roundToolsr   Úerrorsr	   r   r   r   r$   r*   r   r   r   Úobjectr   r   rÅ   rŸ   ÚdoctestÚsysr'   ÚargvÚexitÚtestmodÚfailedr   r   r   r   Ú<module>   s*   


2
Q  a
8