403Webshell
Server IP : 202.61.199.114  /  Your IP : 216.73.217.139
Web Server : nginx/1.22.1
System : Linux de.arni-solutions.de 6.1.0-49-amd64 #1 SMP PREEMPT_DYNAMIC Debian 6.1.174-1 (2026-05-26) x86_64
User : web20 ( 1018)
PHP Version : 8.4.23
Disable Function : NONE
MySQL : OFF  |  cURL : ON  |  WGET : ON  |  Perl : ON  |  Python : OFF  |  Sudo : ON  |  Pkexec : ON
Directory :  /usr/local/lib/python3.9/dist-packages/matplotlib/__pycache__/

Upload File :
current_dir [ Writeable ] document_root [ Writeable ]

 

Command :

[ Back ]     

Current File : /usr/local/lib/python3.9/dist-packages/matplotlib/__pycache__/dviread.cpython-39.pyc
a

���h���@s:dZddlmZddlZddlmZmZmZddlZddl	Z	ddl
mZddlZddl
Z
ddlZddlZddlZddlmZmZe�e�Ze�dd�Zed	d
�Zedd�ZGd
d�dedd��Zedd�dd�dd�dd�dd�dd�dd�dd�d�ZdQdd�ZGdd�d�Z Gdd �d �Z!Gd!d"�d"e �Z"d#d$�Z#Gd%d&�d&�Z$ed'd(�Z%Gd)d*�d*�Z&d+d,�Z'Gd-d.�d.�Z(ed/d0��Z)ed1d2��Z*ee*e$d3�Z+ee*e"d4�Z,ed5k�r6dd6l-m.Z.ddl/Z/e.�Z0e0�1d7�e0j1d8d9e2dd:�e0�3�Z4e e4j5e4j6���*Z7e&e)d;��Z8e7D�]Z9e:d<e9j;�d=e9j<�d>e9j=�d?��e/�>e9j?d@d��D]�\Z@ZAe:dAe@jB�CdB��dCe@jDdD���e:dEdFdGdHdIdJdKdL�eAD]<Z?e:e?jEe?jFe?jGeHe?jG��I��r�eHe?jG�ndMe?j;dKdL��q��qFe9jJ�re:dEdFdNdIdOdPdKdL�e9jJD] ZKe:eKjEeKjFeKj<eKj;dKdL��q�qWd�n1�s,0YdS)RaC
A module for reading dvi files output by TeX. Several limitations make
this not (currently) useful as a general-purpose dvi preprocessor, but
it is currently used by the pdf backend for processing usetex text.

Interface::

  with Dvi(filename, 72) as dvi:
      # iterate over pages:
      for page in dvi:
          w, h, d = page.width, page.height, page.descent
          for x, y, font, glyph, width in page.text:
              fontname = font.texname
              pointsize = font.size
              ...
          for x, y, height, width in page.boxes:
              ...
�)�
namedtupleN)�	lru_cache�partial�wraps)�Path)�_api�cbookZDviStatez!pre outer inpage post_post finale�Pageztext boxes height width descent�Boxzx y height widthc@sHeZdZdZdd�Zedd��Zedd��Zedd	��Zed
d��Z	dS)
�Texta�
    A glyph in the dvi file.

    The *x* and *y* attributes directly position the glyph.  The *font*,
    *glyph*, and *width* attributes are kept public for back-compatibility,
    but users wanting to draw the glyph themselves are encouraged to instead
    load the font specified by `font_path` at `font_size`, warp it with the
    effects specified by `font_effects`, and load the glyph specified by
    `glyph_name_or_index`.
    cCsttd��|jjS)N�
pdftex.map)�
PsfontsMap�
find_tex_file�font�texname��self�r�</usr/local/lib/python3.9/dist-packages/matplotlib/dviread.py�_get_pdftexmap_entryMszText._get_pdftexmap_entrycCs<|��}|jdur2td�|j�d�|j�d����t|j�S)z/The `~pathlib.Path` to the font for this glyph.NzINo usable font file found for {} ({}); the font may lack a Type-1 version�ascii)r�filename�
ValueError�format�psname�decoderr)rZpsfontrrr�	font_pathPs


�zText.font_pathcCs|jjS)zThe font size.)r�sizerrrr�	font_size[szText.font_sizecCs
|��jS)z�
        The "font effects" dict for this glyph.

        This dict contains the values for this glyph of SlantFont and
        ExtendFont (if any), read off :file:`pdftex.map`.
        )r�effectsrrrr�font_effects`szText.font_effectscCs(|��}|jdur"t|j�|jS|jS)a�
        Either the glyph name or the native charmap glyph index.

        If :file:`pdftex.map` specifies an encoding for this glyph's font, that
        is a mapping of glyph indices to Adobe glyph names; use it to convert
        dvi indices to glyph names.  Callers can then convert glyph names to
        glyph indices (with FT_Get_Name_Index/get_name_index), and load the
        glyph using FT_Load_Glyph/load_glyph.

        If :file:`pdftex.map` specifies no encoding, the indices directly map
        to the font's "native" charmap; glyphs should directly load using
        FT_Load_Char/load_char after selecting the native charmap.
        N)r�encoding�
_parse_enc�glyph)r�entryrrr�glyph_name_or_indexjs
��zText.glyph_name_or_indexN)
�__name__�
__module__�__qualname__�__doc__r�propertyrrr r%rrrrrAs



	rzx y font glyph widthcCs|S�Nr��dvi�deltarrr�<lambda>��r/cCs|jddd�S�N�F��signed��_argr,rrrr/�r0cCs|jddd�S)N�Fr3r5r,rrrr/�r0cCs|jddd�S)Nr7Tr3r5r,rrrr/�r0cCs|r|j|dd�SdS)NTr3r5r,rrrr/�r0cCs|j|ddd�S)Nr2Tr3r5r,rrrr/�r0cCs|j|ddd�Sr1r5r,rrrr/�r0cCs|j|d|dkd�S)Nr2�r3r5r,rrrr/�r0)�raw�u1�u4�s4�slen�slen1�ulen1�olen1�r9cs�����fdd�}|S)a�
    Decorator for dispatch by opcode. Sets the values in *table*
    from *min* to *max* to this method, adds a check that the Dvi state
    matches *state* if not None, reads arguments from the file according
    to *args*.

    Parameters
    ----------
    table : dict[int, callable]
        The dispatch table to be filled in.

    min, max : int
        Range of opcodes that calls the registered function; *max* defaults to
        *min*.

    state : _dvistate, optional
        State of the Dvi object in which these opcodes are allowed.

    args : list[str], default: ['raw']
        Sequence of argument specifications:

        - 'raw': opcode minus minimum
        - 'u1': read one unsigned byte
        - 'u4': read four bytes, treat as an unsigned number
        - 's4': read four bytes, treat as a signed number
        - 'slen': read (opcode - minimum) bytes, treat as signed
        - 'slen1': read (opcode - minimum + 1) bytes, treat as signed
        - 'ulen1': read (opcode - minimum + 1) bytes, treat as unsigned
        - 'olen1': read (opcode - minimum + 1) bytes, treat as unsigned
          if under four bytes, signed if four bytes
    csjdd��D��t������fdd��}�dur:|��<n,t��d�D]}�|dus\J�|�|<qH|S)NcSsg|]}t|�qSr)�_arg_mapping��.0�xrrr�
<listcomp>�r0z/_dispatch.<locals>.decorate.<locals>.<listcomp>cs<�dur�j�krtd����g���fdd��D��R�S)Nzstate precondition failedcsg|]}|�����qSrr)rD�f)�byte�minrrrrF�r0z@_dispatch.<locals>.decorate.<locals>.wrapper.<locals>.<listcomp>)�stater)rrH)�get_args�methodrIrJ)rHrr�wrapper�sz,_dispatch.<locals>.decorate.<locals>.wrapperr2)r�range)rLrM�i��args�maxrIrJ�table)rKrLr�decorate�s

z_dispatch.<locals>.decorater)rSrIrRrJrQrTrrPr�	_dispatch�s rUc@s�eZdZdZdgdZeee�Zdd�Zdd�Zdd	�Z	d
d�Z
dd
�Zdd�Zdd�Z
ddd�Zeddejd�dd��Zeddejdd�dd��Zed ejd!d"�d#d$��Zed%d&ejdd�d'd(��Zd)d*�Zed+ejd!d"�d,d-��Zd.d/�Zed0�d1d2��Zed3ejd4d"�d5d6��Zed7ejd8�d9d:��Zed;ejd8�d<d=��Zed>ejd8�d?d@��ZedAdBejdCd�dDdE��ZedFdGejdHd�dIdJ��ZedKdLejdHd�dMdN��Z edOdPejdCd�dQdR��Z!edSdTejdHd�dUdV��Z"edWdXejdHd�dYdZ��Z#ed[d\ejd�d]d^��Z$ed_d`ejdd�dadb��Z%edcdddedf�dgdh��Z&edidjdkdf�dldm��Z'dndo�Z(edpej)dqd"�drds��Z*edtejd8�dudv��Z+edw�dxdy��Z,edzd{d|�d}d~��Z-dS)��DviaI
    A reader for a dvi ("device-independent") file, as produced by TeX.

    The current implementation can only iterate through pages in order,
    and does not even attempt to verify the postamble.

    This class can be used as a context manager to close the underlying
    file upon exit. Pages can be read via iteration. Here is an overly
    simple way to extract text without trying to detect whitespace::

        >>> with matplotlib.dviread.Dvi('input.dvi', 72) as dvi:
        ...     for page in dvi:
        ...         print(''.join(chr(t.glyph) for t in page.text))
    N�cCs0t�d|�t|d�|_||_i|_tj|_dS)z�
        Read the data from the file named *filename* and convert
        TeX's internal units to units of *dpi* per inch.
        *dpi* only sets the units and does not limit the resolution.
        Use None to return TeX's internal units.
        zDvi: %s�rbN)	�_log�debug�open�file�dpi�fonts�	_dvistate�prerJ)rrr]rrr�__init__�s
zDvi.__init__cCs|S)z+Context manager enter method, does nothing.rrrrr�	__enter__�sz
Dvi.__enter__cCs|��dS)zX
        Context manager exit method, closes the underlying file if it is open.
        N)�close)r�etypeZevalueZetracerrr�__exit__�szDvi.__exit__ccs|��r|��VqdS)a\
        Iterate through the pages of the file.

        Yields
        ------
        Page
            Details of all the text and box objects on the page.
            The Page tuple contains lists of Text and Box tuples and
            the page dimensions, and the Text and Box tuples contain
            coordinates transformed into a standard Cartesian
            coordinate system at the dpi value given when initializing.
            The coordinates are floating point numbers, but otherwise
            precision is not lost and coordinate values are not clipped to
            integers.
        N)�_read�_outputrrrr�__iter__�szDvi.__iter__cCs|jjs|j��dS)z(Close the underlying file if it is open.N)r\�closedrcrrrrrcsz	Dvi.closecs~tjtjtjtjf\�}}�tj}|j|jD]z}t|t�rT|\}}}}d}	n|\}}}
}}|
�|�\}}	t�|��t|||�}t|||�}t�||	��t||�}q4|j	dur�|j	}d|_	|js�|js�t
ggdddd�S|jdu�rt
|j|j|�||�|d�S|jd��|������fdd�|jD�}����fdd�|jD�}
t
||
|��||��d�S)zk
        Output the text and boxes belonging to the most recent page.
        page = dvi._output()
        rN��text�boxes�width�height�descentg�z�GRAc	s>g|]6\}}}}}t|���|��|||���qSr)r)rDrE�yrG�g�w��droZmaxyZminxrrrF0s�zDvi._output.<locals>.<listcomp>cs>g|]6\}}}}t|���|��|�|���qSr)r
)rDrErp�hrrrsrrrF2s
�)�np�infrkrl�
isinstancer
�_height_depth_ofrIrR�_baseline_vr	r])rZminyZmaxxZ	maxy_pure�eltrErprurr�errqrkrlrrsrrgsD 



�
���zDvi._outputcCs�dg}d|_|j�d�d}|j|||�|j|j}|dkrP|�|d�n*|dkrb|��n|dkrz|dd7<|jdur�tt|dg��d	kr�|dd
kr�|j	|_|dkr�dS|j
tjur|�
�d
SqdS)�t
        Read one page from the file. Return True if successful,
        False if there were no more pages.
        rNr2�_push����_pop�_down�stackr8r7�TF)rzr\�read�_dtabler&�append�pop�len�getattr�vrJr_�	post_postrc)rZ
down_stackrH�namerrrrf8s,

�
�z	Dvi._readFcCstj|j�|�d|d�S)z
        Read and return a big-endian integer *nbytes* long.
        Signedness is determined by the *signed* keyword.
        �bigr3)�int�
from_bytesr\r�)r�nbytesr4rrrr6eszDvi._argr�)rIrRrJcCs*|�|�|j|j|j�|�7_dSr+��_put_char_realrur^rG�	_width_of�r�charrrr�_set_char_immediatels
zDvi._set_char_immediate��)r@)rIrRrJrQcCs*|�|�|j|j|j�|�7_dSr+r�r�rrr�	_set_charqs
z
Dvi._set_char�)r<r<)rJrQcCs|�||�|j|7_dSr+)�_put_rule_realru�r�a�brrr�	_set_rulevsz
Dvi._set_rule��cCs|�|�dSr+)r�r�rrr�	_put_char{sz
Dvi._put_charc	s��j�j}|jdur:�j�t�j�j|||�|���n�|j	�|j|jD]b\}}}}}t
t�|j	�|j|j
|jd�}�j�t�jt|���jt|��|||�|���qL�j���fdd�|j|jD��dS)N��scale�tfmr�vfc	sFg|]>\}}}}t�jt|���jt|��t|��t|����qSr)r
ru�_mul2012r�)rDrErpr�r��r�rrrrF�s

��z&Dvi._put_char_real.<locals>.<listcomp>)r^rG�_vfrkr�rrur�r��_scale�DviFontr��_tfmrrl�extend)	rr�rrErprGrqrrZnewfrr�rr�s"
���
�zDvi._put_char_real�cCs|�||�dSr+)r�r�rrr�	_put_rule�sz
Dvi._put_rulecCs.|dkr*|dkr*|j�t|j|j||��dS�Nr)rlr�r
rur�r�rrrr��szDvi._put_rule_real�cCsdSr+r�r�_rrr�_nop�szDvi._nop�)r<r<r<r<r<r<r<r<r<r<r<cCs:tj|_d\|_|_|_|_|_|_g|_	g|_
g|_dS)N�rrrrrr)r_�inpagerJrur�rrrErp�zr�rkrl)rZc0Zc1�c2�c3Zc4Zc5Zc6Zc7Zc8Zc9�prrr�_bop�s
zDvi._bopr�)rJcCs(tj|_|`|`|`|`|`|`|`	dSr+)
r_�outerrJrur�rrrErpr�r�r�rrr�_eop�szDvi._eop�cCs(|j�|j|j|j|j|j|jf�dSr+)r�r�rur�rrrErpr�r�rrrr~�sz	Dvi._push�cCs&|j��\|_|_|_|_|_|_dSr+)r�r�rur�rrrErpr�r�rrrr��szDvi._pop��)r>cCs|j|7_dSr+)ru)rr�rrr�_right�sz
Dvi._right��)r=cCs"|dur||_|j|j7_dSr+)rrru)rZnew_wrrr�_right_w�szDvi._right_w��cCs"|dur||_|j|j7_dSr+)rEru)rZnew_xrrr�_right_x�szDvi._right_x��cCs|j|7_dSr+)r�)rr�rrrr��sz	Dvi._down��cCs"|dur||_|j|j7_dSr+)rpr�)rZnew_yrrr�_down_y�szDvi._down_y��cCs"|dur||_|j|j7_dSr+)r�r�)rZnew_zrrr�_down_z�szDvi._down_z���cCs
||_dSr+�rG)r�krrr�_fnt_num_immediate�szDvi._fnt_num_immediate����cCs
||_dSr+r�)r�new_frrr�_fnt_num�szDvi._fnt_num����)r?)rIrRrQcCs,|j�|�}t�dd�dd�|D���dS)Nz!Dvi._xxx: encountered special: %s�cSs4g|],}d|krdkr(nnt|�nd|�qS)� r�z<%02x>)�chr)rD�chrrrrF�s�zDvi._xxx.<locals>.<listcomp>)r\r�rYrZ�join)rZdatalen�specialrrr�_xxx�s
��zDvi._xxx���)r@r;r;r;r:r:cCs|�||||||�dSr+)�
_fnt_def_real)rr��c�srtr��lrrr�_fnt_def�szDvi._fnt_defcCs�|j�||�}||d��d�}t|�}	|dkrT|	jdkrT||	jkrTtd|��zt|�}
Wntyvd}
Yn0t||	||
d�|j	|<dS)Nrrztfm checksum mismatch: %sr�)
r\r�r�_tfmfile�checksumr�_vffile�FileNotFoundErrorr�r^)rr�r�r�rtr�r��nZfontnamer�r�rrrr��s
zDvi._fnt_def_real�)r:r;r;r;r:cCsT|j�|�|dkr td|��|dks0|dkr8td��|dkrHtd��tj|_dS)N�zUnknown dvi format %di���i;zNonstandard units in dvi file��z%Nonstandard magnification in dvi file)r\r�rr_r�rJ)rrO�numZdenZmagr�rrr�_pre�szDvi._pre�cCstj|_dSr+)r_r�rJr�rrr�_postsz	Dvi._post�cCst�dSr+)�NotImplementedErrorr�rrr�
_post_post
szDvi._post_post��)rIrRcCstdd|����dS)Nzunknown command: byte r�)r)r�offsetrrr�
_malformedszDvi._malformed)F).r&r'r(r)r�rrUrarbrerhrcrgrfr6r_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�rrrrrV�s|


,-
























rVc@sDeZdZdZdZdd�Zdd�Zdd�Zd	d
�Zdd�Z	d
d�Z
dS)r�au
    Encapsulation of a font that a DVI file can refer to.

    This class holds a font's texname and size, supports comparison,
    and knows the widths of glyphs in the same units as the AFM file.
    There are also internal attributes (for use by dviread.py) that
    are *not* used for comparison.

    The size is in Adobe points (converted from TeX points).

    Parameters
    ----------
    scale : float
        Factor by which the font is scaled from its natural size.
    tfm : Tfm
        TeX font metrics for this font
    texname : bytes
       Name of the font as used internally by TeX and friends, as an ASCII
       bytestring.  This is usually very different from any external font
       names; `PsfontsMap` can be used to find the external name of the font.
    vf : Vf
       A TeX "virtual font" file, or None if this font is not virtual.

    Attributes
    ----------
    texname : bytes
    size : float
       Size of the font in Adobe points, converted from the slightly
       smaller TeX points.
    widths : list
       Widths of glyphs in glyph-space units, typically 1/1000ths of
       the point size.

    )rr�widthsr�r�r�csvtjt|d�||_�|_||_||_|d|_zt�j	�d}Wnt
yXd}Yn0�fdd�t|�D�|_dS)N)rg]�e��>r2rcs"g|]}d�j�|d�d?�qS)r�r�)rm�get)rDr��r�rrrFCs�z$DviFont.__init__.<locals>.<listcomp>)
rZcheck_isinstance�bytesr�r�rr�rrRrmrrNr�)rr�r�rr�Zncharsrrrra8s


�zDviFont.__init__cCs(t|�t|�uo&|j|jko&|j|jkSr+)�typerr�r�otherrrr�__eq__Fs

�
�zDviFont.__eq__cCs|�|�Sr+)rrrrr�__ne__JszDviFont.__ne__cCsdt|�j�d|j�d�S)N�<z: �>)rr&rrrrr�__repr__MszDviFont.__repr__cCs8|jj�|d�}|dur$t||j�St�d||j�dS)zWidth of char in dvi units.Nz No width for char %d in font %s.r)r�rmrr�r�rYrZr)rr�rmrrrr�Ps
zDviFont._width_ofcCs�g}|jjdf|jjdffD]L\}}|�|d�}|durVt�d|||j�|�d�q|�t||j	��qt
�d|j�r�|dkr�d|d<|S)z&Height and depth of char in dvi units.rn�depthNzNo %s for char %d in font %srs	^cmsy\d+$r)r�rnrrrYrZrr�r�r��re�match)rr��resultZmetricr��valuerrrryXs

��zDviFont._height_depth_ofN)r&r'r(r)�	__slots__rarrrr�ryrrrrr�s"r�csHeZdZdZ�fdd�Zdd�Zdd�Zdd	�Zd
d�Zdd
�Z	�Z
S)�Vfa�
    A virtual font (\*.vf file) containing subroutines for dvi files.

    Parameters
    ----------
    filename : str or path-like

    Notes
    -----
    The virtual font format is a derivative of dvi:
    http://mirrors.ctan.org/info/knuth/virtual-fonts
    This class reuses some of the machinery of `Dvi`
    but replaces the `_read` loop and dispatch mechanism.

    Examples
    --------
    ::

        vf = Vf(filename)
        glyph = vf[code]
        glyph.text, glyph.boxes, glyph.width
    cs>t��|d�z d|_i|_|��W|��n
|��0dSr�)�superra�_first_font�_charsrfrc)rr��	__class__rrra�s
zVf.__init__cCs
|j|Sr+)r)r�coderrr�__getitem__�szVf.__getitem__cs�d\}}d\}}�j�d�d}�jtjur��j��d}||krZ��||�d\}}}n@||krltd��n.|dvs||dkr�td|��tj	|�|�q|d	kr�|}��
d���
d
�}}��|�}tj�_q|d	k�r��fdd�d
D�\}}}��|�qd|k�rdk�rrnnX��
|d	|dk�}�fdd�dD�\}}	}
}}��|||	|
||��j
du�r�|�_
q|dk�rƈ�
d���
d�}
}�j�|�}��
d���
d�}}��|
|||�q|dk�r֐q�qtd|��qdS)r})NNr2r)NNNz!Packet length mismatch in vf file)r�r�r�z"Inappropriate opcode %d in vf filer�r8csg|]}��|��qSrr5rCrrrrF�r0zVf._read.<locals>.<listcomp>)r7r7r7r�csg|]}��|��qSrr5rCrrrrF�r0)r7r7r7r2r2Nr�r7r�zUnknown vf opcode %d)r\r�rJr_r��tell�_finalize_packetrrVr�r6�_init_packetr�rr�)r�packet_charZpacket_endsZ
packet_len�packet_widthrHZbyte_atr�r�r�rtr�r�rOrE�cs�dsrrrrf�sN
�


�

zVf._readcCs\|jtjkrtd��d\|_|_|_|_|_|_	ggg|_
|_|_|j
|_|j��|S)NzMisplaced packet in vf filer�)rJr_r�rrur�rrrErpr�r�rkrlrrGr\r)r�plrrrr�szVf._init_packetcCs(t|j|j|ddd�|j|<tj|_dS)Nrj)r	rkrlrr_r�rJ)rrrrrrr�s

�zVf._finalize_packetcCsH|jtjurtd��|dkr(td|��t|�r<t�d|�tj|_dS)Nz pre command in middle of vf file��zUnknown vf format %dzvf file comment: %s)rJr_r`rr�rYrZr�)rrOrErr rrrr��szVf._pre)r&r'r(r)rarrfrrr��
__classcell__rrrrrns	3rcCs||d?S)z1Multiply two numbers in 20.12 fixed point format.rr)Znum1Znum2rrrr��sr�c@seZdZdZdZdd�ZdS)�Tfma
    A TeX Font Metric file.

    This implementation covers only the bare minimum needed by the Dvi class.

    Parameters
    ----------
    filename : str or path-like

    Attributes
    ----------
    checksum : int
       Used for verifying against the dvi file.
    design_size : int
       Design size of the font (unknown units)
    width, height, depth : dict
       Dimensions of each character, need to be scaled by the factor
       specified in the dvi file. These are dicts because indexing may
       not start from 0.
    )r��design_sizermrnrc
Cs�t�d|�t|d���}|�d�}t�d|dd��\}}}}}}	t�d||||||	�|�d|�}
t�d	|
dd
��\|_|_|�d||d�}t�d|�d
�|�d|��}t�d|�d
�|�d|��}
t�d|	�d
�|�d|	��}Wd�n1�s0Yiii|_|_	|_
tt||d��D]X\}}|d|}|d|d}|||j|<|
|d?|j	|<||d@|j
|<�q:dS)Nzopening tfm file %srX�z!6Hr��z(lh=%d, bc=%d, ec=%d, nw=%d, nh=%d, nd=%dr7z!2I�r2�!rO�)
rYrZr[r��struct�unpackr�r%rmrnr�	enumeraterN)rrr\Zheader1ZlhZbc�ec�nwZnhZndZheader2Z	char_infor�ZheightsZdepths�idxr�Zbyte0Zbyte1rrrra�s(
 �>zTfm.__init__N)r&r'r(r)rrarrrrr$�sr$�PsFontz(texname psname effects encoding filenamec@s0eZdZdZdZedd��Zdd�Zdd�Zd	S)
r
a}
    A psfonts.map formatted file, mapping TeX fonts to PS fonts.

    Parameters
    ----------
    filename : str or path-like

    Notes
    -----
    For historical reasons, TeX knows many Type-1 fonts by different
    names than the outside world. (For one thing, the names have to
    fit in eight characters.) Also, TeX's native fonts are not Type-1
    but Metafont, which is nontrivial to convert to PostScript except
    as a bitmap. While high-quality conversions to Type-1 format exist
    and are shipped with modern TeX distributions, we need to know
    which Type-1 fonts are the counterparts of which native fonts. For
    these reasons a mapping is needed from internal font names to font
    file names.

    A texmf tree typically includes mapping files called e.g.
    :file:`psfonts.map`, :file:`pdftex.map`, or :file:`dvipdfm.map`.
    The file :file:`psfonts.map` is used by :program:`dvips`,
    :file:`pdftex.map` by :program:`pdfTeX`, and :file:`dvipdfm.map`
    by :program:`dvipdfm`. :file:`psfonts.map` might avoid embedding
    the 35 PostScript fonts (i.e., have no filename for them, as in
    the Times-Bold example above), while the pdf-related files perhaps
    only avoid the "Base 14" pdf fonts. But the user may have
    configured these files differently.

    Examples
    --------
    >>> map = PsfontsMap(find_tex_file('pdftex.map'))
    >>> entry = map[b'ptmbo8r']
    >>> entry.texname
    b'ptmbo8r'
    >>> entry.psname
    b'Times-Bold'
    >>> entry.encoding
    '/usr/local/texlive/2008/texmf-dist/fonts/enc/dvips/base/8r.enc'
    >>> entry.effects
    {'slant': 0.16700000000000001}
    >>> entry.filename
    )�	_filename�	_unparsed�_parsedcCs~t�|�}t�|�|_t|d��D}i|_|D](}|�dd�d}|j�|g��	|�q,Wd�n1sj0Yi|_
|S)NrX� r2r)�object�__new__�os�fsdecoder2r[r3�split�
setdefaultr�r4)�clsrrr\�line�tfmnamerrrr7Fs
4zPsfontsMap.__new__c	Cs|t|t�sJ�||jvr8|j�|�D]}|�|�r$q8q$z|j|WStyvtd|�d��d|j	�d��d�Yn0dS)NzWAn associated PostScript font (required by Matplotlib) could not be found for TeX font rz in zo; this problem can often be solved by installing a suitable PostScript font package in your TeX package manager)
rxrr3r��_parse_and_cache_liner4�KeyError�LookupErrorrr2)rrr=rrrrVs"

����zPsfontsMap.__getitem__cCs@|r|�d�rdSd}}}}}d}}}	t�d|�}
|
D]�}|��\}}
|
r�|
�d�rn|
dd�}q�|
�d�r�|
dd�}q�|
�d�r�|
d	d�p�ttdt|
�����}|�d
�r�|}q�|}d}q�|dur�|
}q�|dur�|
}qB|rB|}qBi}|�rJt|���}|D]<}|dk�r,t	t|��|d
<n|dk�rt	t|��|d<�q|du�rx|�d��rfd}	n|�d��s�d}n|du�r�d}|	�r�|�r�|du�r�dS|�s�d
|v�s�d|v�r�dSt
|�d
d��d	k�r�dSt
|�dd��dk�r�dS|du�r|}|du�rt|�}|du�r$t|�}t
|||||d�|j|<dS)a%
        Parse a line in the font mapping file.

        The format is (partially) documented at
        http://mirrors.ctan.org/systems/doc/pdftex/manual/pdftex-a.pdf
        https://tug.org/texinfohtml/dvips.html#psfonts_002emap
        Each line can have the following fields:

        - tfmname (first, only required field),
        - psname (defaults to tfmname, must come immediately after tfmname if
          present),
        - fontflags (integer, must come immediately after psname if present,
          ignored by us),
        - special (SlantFont and ExtendFont, only field that is double-quoted),
        - fontfile, encodingfile (optional, prefixed by <, <<, or <[; << always
          precedes a font, <[ always precedes an encoding, < can precede either
          but then an encoding file must have extension .enc; < and << also
          request different font subsetting behaviors but we ignore that; < can
          be separated from the filename by whitespace).

        special, fontfile, and encodingfile can appear in any order.
        )r5�%�*�;�#NFs"([^"]*)(?:"|$)|(\S+)s<<r�s<[�<r2s.encTs	SlantFontZslants
ExtendFontr�)s.ttfs.ttcs.otfr)rrrr!r)�
startswithr
�finditer�groups�next�filter�endswith�reversedr:�float�absrrr1r4)rr=r>�basenamer�ZencodingfileZfontfileZis_subsettedZis_t1Zis_truetype�matchesr�quotedZunquoted�wordr�wordsrrrr?fsx


�







�z PsfontsMap._parse_and_cache_lineN)	r&r'r(r)rrr7rr?rrrrr
s+
r
cCsrt�ddt|�jdd��}t�d|��d�}dd�|��D�}td	d
�|D��r^dd�|D�Std|�d
���dS)aE
    Parse a \*.enc file referenced from a psfonts.map style file.

    The format supported by this function is a tiny subset of PostScript.

    Parameters
    ----------
    path : `os.PathLike`

    Returns
    -------
    list
        The nth entry of the list is the PostScript glyph name of the nth
        glyph.
    z%.*r�r)r!z(?s)\[(.*)\]r2cSsg|]}|r|�qSrr�rDr=rrrrF�r0z_parse_enc.<locals>.<listcomp>css|]}|�d�VqdS)�/N)rGrUrrr�	<genexpr>�r0z_parse_enc.<locals>.<genexpr>cSsg|]}|dd��qS)r2NrrUrrrrF�r0zFailed to parse z as Postscript encodingN)	r
�subr�	read_text�search�groupr:�allr)�pathZno_comments�array�linesrrrr"�sr"c@s(eZdZedd��Zdd�Zdd�ZdS)�_LuatexKpsewhichcCst�|�}|��|_|Sr+)r6r7�	_new_proc�_proc)r<rrrrr7�s

z_LuatexKpsewhich.__new__cCs$tjddtt�d��gtjtjd�S)NZluatexz	--luaonlyz
kpsewhich.lua)�stdin�stdout)�
subprocess�Popen�strrZ_get_data_path�PIPErrrrra�s��z_LuatexKpsewhich._new_proccCsb|j��dur|��|_|jj�t�|�d�|jj��|jj�	��
�}|dkrXdSt�|�S)N�
snil)rb�pollrarc�writer8�fsencode�flushrd�readline�rstripr9)rr�outrrrrZ�s
z_LuatexKpsewhich.searchN)r&r'r(rr7rarZrrrrr`�s
r`c	Cs�t|t�r|jddd�}z
t�}Wnty8d}Yn0|rJ|�|�}nptjdkrnitj	�ddi�dd�}nt�
�dd	�}z"tjd
|gt
fi|���d�}Wnttfy�d}Yn0|r�|Std|�d
���dS)a�
    Find a file in the texmf tree using kpathsea_.

    The kpathsea library, provided by most existing TeX distributions, both
    on Unix-like systems and on Windows (MikTeX), is invoked via a long-lived
    luatex process if luatex is installed, or via kpsewhich otherwise.

    .. _kpathsea: https://www.tug.org/kpathsea/

    Parameters
    ----------
    filename : str or path-like

    Raises
    ------
    FileNotFoundError
        If the file is not found.
    zutf-8�replace)�errorsN�win32Zcommand_line_encoding)�envr!�surrogateescape)r!rrZ	kpsewhich�
z:Matplotlib's TeX implementation searched for a file named z* in your texmf tree, but could not find it)rxrrr`r�rZ�sys�platformr8�environ�getfilesystemencodingrZ_check_and_log_subprocessrYro�RuntimeError)rZlkr]�kwargsrrrr�s@



��
���
��rcCs|t||��Sr+)r)r<�suffixrrrr�	_fontfile0sr~z.tfmz.vf�__main__)�ArgumentParserrr]�?)�nargsr�defaultrz=== new page === (w: z, h: z, d: �)cCs|jSr+)r)rkrrrr/Gr0zfont: zlatin-1z	scale: irErpr#r�rrz(glyphs)�	)�sep�.rur�z(boxes))NNrA)Lr)�collectionsr�enum�	functoolsrrr�loggingr8�pathlibrr
r+rerw�numpyrvZ
matplotlibrr�	getLoggerr&rY�Enumr_r	r
r�dictrBrUrVr�rr�r$r1r
r"r`rr~r�r��argparser��	itertools�parser�add_argumentrN�
parse_argsrQrr]r-Zfontmap�page�printrmrnro�groupbyrkrr[rrr�rErpr#r��isprintablerlZboxrrrr�<module>s�


B�
2K[p.
2
:



���

���


Youez - 2016 - github.com/yon3zu
LinuXploit