File manager - Edit - /home/newsbmcs.com/public_html/static/img/logo/formatters.zip
Back
PK J�Z['*�� � other.pynu �[��� """ pygments.formatters.other ~~~~~~~~~~~~~~~~~~~~~~~~~ Other formatters: NullFormatter, RawTokenFormatter. :copyright: Copyright 2006-2021 by the Pygments team, see AUTHORS. :license: BSD, see LICENSE for details. """ from pip._vendor.pygments.formatter import Formatter from pip._vendor.pygments.util import get_choice_opt from pip._vendor.pygments.token import Token from pip._vendor.pygments.console import colorize __all__ = ['NullFormatter', 'RawTokenFormatter', 'TestcaseFormatter'] class NullFormatter(Formatter): """ Output the text unchanged without any formatting. """ name = 'Text only' aliases = ['text', 'null'] filenames = ['*.txt'] def format(self, tokensource, outfile): enc = self.encoding for ttype, value in tokensource: if enc: outfile.write(value.encode(enc)) else: outfile.write(value) class RawTokenFormatter(Formatter): r""" Format tokens as a raw representation for storing token streams. The format is ``tokentype<TAB>repr(tokenstring)\n``. The output can later be converted to a token stream with the `RawTokenLexer`, described in the :doc:`lexer list <lexers>`. Only two options are accepted: `compress` If set to ``'gz'`` or ``'bz2'``, compress the output with the given compression algorithm after encoding (default: ``''``). `error_color` If set to a color name, highlight error tokens using that color. If set but with no value, defaults to ``'red'``. .. versionadded:: 0.11 """ name = 'Raw tokens' aliases = ['raw', 'tokens'] filenames = ['*.raw'] unicodeoutput = False def __init__(self, **options): Formatter.__init__(self, **options) # We ignore self.encoding if it is set, since it gets set for lexer # and formatter if given with -Oencoding on the command line. # The RawTokenFormatter outputs only ASCII. Override here. self.encoding = 'ascii' # let pygments.format() do the right thing self.compress = get_choice_opt(options, 'compress', ['', 'none', 'gz', 'bz2'], '') self.error_color = options.get('error_color', None) if self.error_color is True: self.error_color = 'red' if self.error_color is not None: try: colorize(self.error_color, '') except KeyError: raise ValueError("Invalid color %r specified" % self.error_color) def format(self, tokensource, outfile): try: outfile.write(b'') except TypeError: raise TypeError('The raw tokens formatter needs a binary ' 'output file') if self.compress == 'gz': import gzip outfile = gzip.GzipFile('', 'wb', 9, outfile) write = outfile.write flush = outfile.close elif self.compress == 'bz2': import bz2 compressor = bz2.BZ2Compressor(9) def write(text): outfile.write(compressor.compress(text)) def flush(): outfile.write(compressor.flush()) outfile.flush() else: write = outfile.write flush = outfile.flush if self.error_color: for ttype, value in tokensource: line = b"%r\t%r\n" % (ttype, value) if ttype is Token.Error: write(colorize(self.error_color, line)) else: write(line) else: for ttype, value in tokensource: write(b"%r\t%r\n" % (ttype, value)) flush() TESTCASE_BEFORE = '''\ def testNeedsName(lexer): fragment = %r tokens = [ ''' TESTCASE_AFTER = '''\ ] assert list(lexer.get_tokens(fragment)) == tokens ''' class TestcaseFormatter(Formatter): """ Format tokens as appropriate for a new testcase. .. versionadded:: 2.0 """ name = 'Testcase' aliases = ['testcase'] def __init__(self, **options): Formatter.__init__(self, **options) if self.encoding is not None and self.encoding != 'utf-8': raise ValueError("Only None and utf-8 are allowed encodings.") def format(self, tokensource, outfile): indentation = ' ' * 12 rawbuf = [] outbuf = [] for ttype, value in tokensource: rawbuf.append(value) outbuf.append('%s(%s, %r),\n' % (indentation, ttype, value)) before = TESTCASE_BEFORE % (''.join(rawbuf),) during = ''.join(outbuf) after = TESTCASE_AFTER if self.encoding is None: outfile.write(before + during + after) else: outfile.write(before.encode('utf-8')) outfile.write(during.encode('utf-8')) outfile.write(after.encode('utf-8')) outfile.flush() PK J�ZH��{ { $ __pycache__/_mapping.cpython-310.pycnu �[��� o �7]ht � @ sN d Z i dd�dd�dd�dd�d d �d d �d d�dd�dd�dd�dd�dd�dd�dd �d d �d d �d!d"�d#d$i�Zed%k�r%d&d'lZd&d'lZg Zg Zej�d&ej� ej� e �d(d(�� d&d)l m Z e�d*�D ]T\ZZZeD ]LZe�d+�r�e�d,�s�d-ed.d'� �d/d*�ed'd0� f Zee� eed'd'd1g�ZejD ] Ze ee�Z e� d2eee j e e j!�e e j"�e e �ff � q�qoqhe�#� e$e ��Z%e%�&� Z'e'�d3d4�Z'W d' � n1 s�w Y e'd'e'�(d5�� Z)e'e'�(d6�d'� Z*e$e d7�� Z%e%�+e)� e%�+d8d9� e� � e%�+e*� W d' � n 1 �sw Y ed:e,e� � d'S d'S );a� pygments.formatters._mapping ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Formatter mapping definitions. This file is generated by itself. Everytime you change something on a builtin formatter definition, run this script from the formatters folder to update it. Do not alter the FORMATTERS dictionary by hand. :copyright: Copyright 2006-2021 by the Pygments team, see AUTHORS. :license: BSD, see LICENSE for details. �BBCodeFormatter)zpygments.formatters.bbcode�BBCode)�bbcode�bb� z�Format tokens with BBcodes. These formatting codes are used by many bulletin boards, so you can highlight your sourcecode with pygments before posting it there.�BmpImageFormatter)�pygments.formatters.img�img_bmp)�bmp�bitmap)z*.bmpzwCreate a bitmap image from source code. This uses the Python Imaging Library to generate a pixmap from the source code.�GifImageFormatter)r �img_gif)�gif)z*.gifztCreate a GIF image from source code. This uses the Python Imaging Library to generate a pixmap from the source code.�GroffFormatter)zpygments.formatters.groff�groff)r �troff�roffr zFFormat tokens with groff escapes to change their color and font style.� HtmlFormatter)zpygments.formatters.html�HTML)�html)z*.htmlz*.htmz�Format tokens as HTML 4 ``<span>`` tags within a ``<pre>`` tag, wrapped in a ``<div>`` tag. The ``<div>``'s CSS class can be set by the `cssclass` option.� IRCFormatter)zpygments.formatters.irc�IRC)�ircr r z&Format tokens with IRC color sequences�ImageFormatter)r �img)r �IMG�png)z*.pngztCreate a PNG image from source code. This uses the Python Imaging Library to generate a pixmap from the source code.�JpgImageFormatter)r �img_jpg)�jpg�jpeg)z*.jpgzuCreate a JPEG image from source code. This uses the Python Imaging Library to generate a pixmap from the source code.�LatexFormatter)zpygments.formatters.latex�LaTeX)�latex�tex)z*.texzUFormat tokens as LaTeX code. This needs the `fancyvrb` and `color` standard packages.� NullFormatter)�pygments.formatters.otherz Text only)�text�null)z*.txtz1Output the text unchanged without any formatting.�PangoMarkupFormatter)z pygments.formatters.pangomarkupz Pango Markup)�pango� pangomarkupr zFFormat tokens as Pango Markup code. It can then be rendered to an SVG.�RawTokenFormatter)r% z Raw tokens)�raw�tokens)z*.rawz@Format tokens as a raw representation for storing token streams.� RtfFormatter)zpygments.formatters.rtf�RTF)�rtf)z*.rtfz�Format tokens as RTF markup. This formatter automatically outputs full RTF documents with color information and other useful stuff. Perfect for Copy and Paste into Microsoft(R) Word(R) documents.� SvgFormatter)zpygments.formatters.svg�SVG)�svg)z*.svgz�Format tokens as an SVG graphics file. This formatter is still experimental. Each line of code is a ``<text>`` element with explicit ``x`` and ``y`` coordinates containing ``<tspan>`` elements with the individual token styles.�Terminal256Formatter)� pygments.formatters.terminal256� Terminal256)� terminal256� console256�256r z�Format tokens with ANSI color sequences, for output in a 256-color terminal or console. Like in `TerminalFormatter` color sequences are terminated at newlines, so that paging the output works correctly.�TerminalFormatter)z pygments.formatters.terminal�Terminal)�terminal�consoler z�Format tokens with ANSI color sequences, for output in a text console. Color sequences are terminated at newlines, so that paging the output works correctly.�TerminalTrueColorFormatter)r5 �TerminalTrueColor)� terminal16m� console16m�16mr z�Format tokens with ANSI color sequences, for output in a true-color terminal or console. Like in `TerminalFormatter` color sequences are terminated at newlines, so that paging the output works correctly.�TestcaseFormatter)r% �Testcase)�testcaser z0Format tokens as appropriate for a new testcase.�__main__� Nz..)�docstring_headline�.z.py�_zpygments.formatters%s.%s� �/���� z%r: %rz � zFORMATTERS = {zif __name__ == '__main__':�wzFORMATTERS = { %s } z, z === %d formatters processed.)-�__doc__� FORMATTERS�__name__�sys�os�found_formatters�imports�path�insert�join�dirname�__file__�pip._vendor.pygments.utilrH �walk�root�dirs�files�filename�endswith� startswith�replace� module_name�print� __import__�module�__all__�formatter_name�getattr� formatter�append�name�tuple�aliases� filenames�sort�open�fp�read�content�find�header�footer�write�lenr r r �J/usr/lib/python3/dist-packages/pip/_vendor/pygments/formatters/_mapping.py�<module> s� �������� � � � � ������ " � ����� � ��PK J�Z�pb� � ! __pycache__/other.cpython-310.pycnu �[��� o �7]h� � @ sx d Z ddlmZ ddlmZ ddlmZ ddlmZ g d�Z G dd� de�Z G d d � d e�Z d Z d Z G d d� de�ZdS )z� pygments.formatters.other ~~~~~~~~~~~~~~~~~~~~~~~~~ Other formatters: NullFormatter, RawTokenFormatter. :copyright: Copyright 2006-2021 by the Pygments team, see AUTHORS. :license: BSD, see LICENSE for details. � )� Formatter)�get_choice_opt)�Token)�colorize)� NullFormatter�RawTokenFormatter�TestcaseFormatterc @ s* e Zd ZdZdZddgZdgZdd� ZdS ) r z; Output the text unchanged without any formatting. z Text only�text�nullz*.txtc C s8 | j }|D ]\}}|r|�|�|�� q|�|� qd S �N)�encoding�write�encode)�self� tokensource�outfile�enc�ttype�value� r �G/usr/lib/python3/dist-packages/pip/_vendor/pygments/formatters/other.py�format s �zNullFormatter.formatN)�__name__� __module__� __qualname__�__doc__�name�aliases� filenamesr r r r r r s r c @ s6 e Zd ZdZdZddgZdgZdZdd� Zd d � Z d S ) r a} Format tokens as a raw representation for storing token streams. The format is ``tokentype<TAB>repr(tokenstring)\n``. The output can later be converted to a token stream with the `RawTokenLexer`, described in the :doc:`lexer list <lexers>`. Only two options are accepted: `compress` If set to ``'gz'`` or ``'bz2'``, compress the output with the given compression algorithm after encoding (default: ``''``). `error_color` If set to a color name, highlight error tokens using that color. If set but with no value, defaults to ``'red'``. .. versionadded:: 0.11 z Raw tokens�raw�tokensz*.rawFc K s� t j| fi |�� d| _t|dg d�d�| _|�dd �| _| jdu r%d| _| jd urBz t| jd� W d S tyA t d| j ��w d S ) N�ascii�compress)� �none�gz�bz2r# � error_colorT�redzInvalid color %r specified) r �__init__r r r" �getr' r �KeyError� ValueError�r �optionsr r r r) > s" � ���zRawTokenFormatter.__init__c s z�� d� W n ty td��w | jdkr+dd l}|�ddd����j }�j}n#| jdkrHdd l}|�d�� � �fd d �}� �fd d �}n�j }�j}| j rq|D ] \}}d ||f } |t j u rk|t | j | �� qS|| � qSn|D ] \}}|d ||f � qs|� d S )N� z3The raw tokens formatter needs a binary output filer% r r# �wb� r& c s �� � �| �� d S r )r r" )r �� compressorr r r r ` s z'RawTokenFormatter.format.<locals>.writec s �� � �� � ��� d S r )r �flushr r2 r r r4 c s z'RawTokenFormatter.format.<locals>.flushs %r %r ) r � TypeErrorr" �gzip�GzipFile�closer& � BZ2Compressorr4 r' r �Errorr ) r r r r6 r r4 r& r r �liner r2 r r P s6 � � zRawTokenFormatter.formatN) r r r r r r r � unicodeoutputr) r r r r r r $ s r zG def testNeedsName(lexer): fragment = %r tokens = [ zD ] assert list(lexer.get_tokens(fragment)) == tokens c @ s* e Zd ZdZdZdgZdd� Zdd� ZdS ) r zU Format tokens as appropriate for a new testcase. .. versionadded:: 2.0 �Testcase�testcasec K s6 t j| fi |�� | jd ur| jdkrtd��d S d S )N�utf-8z*Only None and utf-8 are allowed encodings.)r r) r r, r- r r r r) � s �zTestcaseFormatter.__init__c C s� d}g }g }|D ]\}}|� |� |� d|||f � qtd�|�f }d�|�} t} | jd u r:|�|| | � n|�|�d�� |�| �d�� |�| �d�� |�� d S )Nz z %s(%s, %r), r# r? )�append�TESTCASE_BEFORE�join�TESTCASE_AFTERr r r r4 ) r r r � indentation�rawbuf�outbufr r �before�during�afterr r r r � s zTestcaseFormatter.formatN)r r r r r r r) r r r r r r � s r N)r � pip._vendor.pygments.formatterr �pip._vendor.pygments.utilr �pip._vendor.pygments.tokenr � pip._vendor.pygments.consoler �__all__r r rA rC r r r r r �<module> s SPK J�ZiF� $ __pycache__/__init__.cpython-310.pycnu �[��� o �7]h� � @ s� d Z ddlZddlZddlZddlZddlmZ ddlmZ ddl m Z ddl m Z g d�e e� Zi Zi Zdd � Zd d � Zd d � Zdd� Zdd� Zddd�Zdd� ZG dd� dej�Zeje Z ee�Z e j � e j � e eje< e ` e ` e `e `dS )z� pygments.formatters ~~~~~~~~~~~~~~~~~~~ Pygments formatters. :copyright: Copyright 2006-2021 by the Pygments team, see AUTHORS. :license: BSD, see LICENSE for details. � N)�basename)� FORMATTERS)�find_plugin_formatters)� ClassNotFound)�get_formatter_by_name�get_formatter_for_filename�get_all_formatters�load_formatter_from_filec C s8 |t vrt�t�|�� }t |< |�| �S t | �| �S )zBReturn whether the supplied file name fn matches pattern filename.)�_pattern_cache�re�compile�fnmatch� translate�match)�fn�glob�pattern� r �J/usr/lib/python3/dist-packages/pip/_vendor/pygments/formatters/__init__.py� _fn_matches s r c C s4 t | dddg�}|jD ] }t||�}|t|j< q dS )z4Load a formatter (and all others in the module too).N�__all__)� __import__r �getattr�_formatter_cache�name)� module_name�mod�formatter_name�clsr r r �_load_formatters$ s �r c c sP � t �� D ]} | d tvrt| d � t| d V qt� D ]\}}|V q dS )z-Return a generator for all formatter classes.� r N)r �valuesr r r )�info�_� formatterr r r r , s � �r c C sb t �� D ]\}}}}}| |v r |tvrt|� t| S qt� D ] \}}| |jv r.| S q!dS )zALookup a formatter by alias. Returns None if not found. N)r r! r r r �aliases)�aliasr r r% r# r r r r �find_formatter_class7 s � ��r' c K s* t | �}|du rtd| ��|di |��S )zYLookup and instantiate a formatter by alias. Raises ClassNotFound if not found. Nz no formatter found for name %rr )r' r )�_alias�optionsr r r r r F s r �CustomFormatterc K s� z6i }t | d��}t|�� |� W d � n1 sw Y ||vr+td|| f ��|| }|di |��W S tyJ } ztd| |f ��d}~w tyQ � tyb } ztd| ��d}~ww )a! Load a formatter from a file. This method expects a file located relative to the current working directory, which contains a class named CustomFormatter. By default, it expects the Formatter to be named CustomFormatter; you can specify your own class name as the second argument to this function. Users should be very careful with the input, because this method is equivalent to running eval on the input file. Raises ClassNotFound if there are any problems importing the Formatter. .. versionadded:: 2.2 �rbNz no valid %s class found in %szcannot read %s: %sz'error when loading custom formatter: %sr )�open�exec�readr �OSError� Exception)�filename� formatternamer) �custom_namespace�f�formatter_class�errr r r r Q s( ��� ��r c K s� t | �} t�� D ]&\}}}}}|D ] }t| |�r-|tvr t|� t| di |�� S qqt� D ]}|jD ]}t| |�rI|di |�� S q7q2td| ��)zdLookup and instantiate a formatter by filename pattern. Raises ClassNotFound if not found. z#no formatter found for file name %rNr ) r r r! r r r r � filenamesr )r r) �modnamer r# r7 r1 r r r r r u s �� �� r c @ s e Zd ZdZdd� ZdS )� _automodulez Automatically import formatters.c C s> t �|�}|rt|d � t|d }t| ||� |S t|��)Nr r )r �getr r �setattr�AttributeError)�selfr r" r r r r � __getattr__� s z_automodule.__getattr__N)�__name__� __module__� __qualname__�__doc__r> r r r r r9 � s r9 )r* ) rB r �sys�typesr �os.pathr �(pip._vendor.pygments.formatters._mappingr �pip._vendor.pygments.pluginr �pip._vendor.pygments.utilr �listr r r r r r r' r r r � ModuleTyper9 �modulesr? �oldmod�newmod�__dict__�updater r r r �<module> s6 � $ PK J�Z�{�4 �4 ! __pycache__/latex.cpython-310.pycnu �[��� o �7]h�I � @ s� d Z ddlmZ ddlmZ ddlmZmZ ddlm Z m Z ddl m Z m Z dgZdd � Zd Zd Zd d � ZG dd� de�ZG dd� de�ZdS )z� pygments.formatters.latex ~~~~~~~~~~~~~~~~~~~~~~~~~ Formatter for LaTeX fancyvrb output. :copyright: Copyright 2006-2021 by the Pygments team, see AUTHORS. :license: BSD, see LICENSE for details. � )�StringIO)� Formatter)�Lexer� do_insertions)�Token�STANDARD_TYPES)� get_bool_opt� get_int_opt�LatexFormatterc C s� | � dd�� dd�� dd�� dd| �� dd| �� dd | �� d d | �� d d | �� dd| �� dd| �� dd| �� dd| �� dd| �� dd| �� dd| �� d d | �� d d | �� d d!| �S )"N�\� �{��}�z\%sZbs{}z\%sZob{}z\%sZcb{}�^z\%sZca{}�_z\%sZus{}�&z\%sZam{}�<z\%sZlt{}�>z\%sZgt{}�#z\%sZsh{}�%z\%sZpc{}�$z\%sZdl{}�-z\%sZhy{}�'z\%sZsq{}�"z\%sZdq{}�~z\%sZti{})�replace)�text� commandprefix� r �G/usr/lib/python3/dist-packages/pip/_vendor/pygments/formatters/latex.py� escape_tex s& �r" z� \documentclass{%(docclass)s} \usepackage{fancyvrb} \usepackage{color} \usepackage[%(encoding)s]{inputenc} %(preamble)s %(styledefs)s \begin{document} \section*{%(title)s} %(code)s \end{document} a� \makeatletter \def\%(cp)s@reset{\let\%(cp)s@it=\relax \let\%(cp)s@bf=\relax%% \let\%(cp)s@ul=\relax \let\%(cp)s@tc=\relax%% \let\%(cp)s@bc=\relax \let\%(cp)s@ff=\relax} \def\%(cp)s@tok#1{\csname %(cp)s@tok@#1\endcsname} \def\%(cp)s@toks#1+{\ifx\relax#1\empty\else%% \%(cp)s@tok{#1}\expandafter\%(cp)s@toks\fi} \def\%(cp)s@do#1{\%(cp)s@bc{\%(cp)s@tc{\%(cp)s@ul{%% \%(cp)s@it{\%(cp)s@bf{\%(cp)s@ff{#1}}}}}}} \def\%(cp)s#1#2{\%(cp)s@reset\%(cp)s@toks#1+\relax+\%(cp)s@do{#2}} %(styles)s \def\%(cp)sZbs{\char`\\} \def\%(cp)sZus{\char`\_} \def\%(cp)sZob{\char`\{} \def\%(cp)sZcb{\char`\}} \def\%(cp)sZca{\char`\^} \def\%(cp)sZam{\char`\&} \def\%(cp)sZlt{\char`\<} \def\%(cp)sZgt{\char`\>} \def\%(cp)sZsh{\char`\#} \def\%(cp)sZpc{\char`\%%} \def\%(cp)sZdl{\char`\$} \def\%(cp)sZhy{\char`\-} \def\%(cp)sZsq{\char`\'} \def\%(cp)sZdq{\char`\"} \def\%(cp)sZti{\char`\~} %% for compatibility with earlier versions \def\%(cp)sZat{@} \def\%(cp)sZlb{[} \def\%(cp)sZrb{]} \makeatother c C sJ t �| �}|r |S d}|d u r!| d | }| j} t �| �}|d u s|| S )N� ���)r �get�parent)�ttype�fname�anamer r r! �_get_ttype_name� s �r* c @ sD e Zd ZdZdZddgZdgZdd� Zdd � Zdd d �Z d d� Z dS )r a� Format tokens as LaTeX code. This needs the `fancyvrb` and `color` standard packages. Without the `full` option, code is formatted as one ``Verbatim`` environment, like this: .. sourcecode:: latex \begin{Verbatim}[commandchars=\\\{\}] \PY{k}{def }\PY{n+nf}{foo}(\PY{n}{bar}): \PY{k}{pass} \end{Verbatim} The special command used here (``\PY``) and all the other macros it needs are output by the `get_style_defs` method. With the `full` option, a complete LaTeX document is output, including the command definitions in the preamble. The `get_style_defs()` method of a `LatexFormatter` returns a string containing ``\def`` commands defining the macros needed inside the ``Verbatim`` environments. Additional options accepted: `style` The style to use, can be a string or a Style subclass (default: ``'default'``). `full` Tells the formatter to output a "full" document, i.e. a complete self-contained document (default: ``False``). `title` If `full` is true, the title that should be used to caption the document (default: ``''``). `docclass` If the `full` option is enabled, this is the document class to use (default: ``'article'``). `preamble` If the `full` option is enabled, this can be further preamble commands, e.g. ``\usepackage`` (default: ``''``). `linenos` If set to ``True``, output line numbers (default: ``False``). `linenostart` The line number for the first line (default: ``1``). `linenostep` If set to a number n > 1, only every nth line number is printed. `verboptions` Additional options given to the Verbatim environment (see the *fancyvrb* docs for possible values) (default: ``''``). `commandprefix` The LaTeX commands used to produce colored output are constructed using this prefix and some letters (default: ``'PY'``). .. versionadded:: 0.7 .. versionchanged:: 0.10 The default is now ``'PY'`` instead of ``'C'``. `texcomments` If set to ``True``, enables LaTeX comment lines. That is, LaTex markup in comment tokens is not escaped so that LaTeX can render it (default: ``False``). .. versionadded:: 1.2 `mathescape` If set to ``True``, enables LaTeX math mode escape in comments. That is, ``'$...$'`` inside a comment will trigger math mode (default: ``False``). .. versionadded:: 1.2 `escapeinside` If set to a string of length 2, enables escaping to LaTeX. Text delimited by these 2 characters is read as LaTeX code and typeset accordingly. It has no effect in string literals. It has no effect in comments if `texcomments` or `mathescape` is set. (default: ``''``). .. versionadded:: 2.0 `envname` Allows you to pick an alternative environment name replacing Verbatim. The alternate environment still has to support Verbatim's option syntax. (default: ``'Verbatim'``). .. versionadded:: 2.0 �LaTeX�latex�texz*.texc K s� t j| fi |�� |�dd�| _|�dd�| _t|dd�| _tt|dd��| _ tt|d d��| _ |�d d�| _ t|d d�| _ |�d d �| _ t|dd�| _t|dd�| _|�dd�| _t| j�dkrn| jd | _| jd | _nd| _|�dd�| _| �� d S )N�docclass�article�preambler# �linenosF� linenostart� � linenostep� verboptions� nobackgroundr �PY� texcomments� mathescape� escapeinside� r �envname�Verbatim)r �__init__r% r. r0 r r1 �absr r2 r4 r5 r6 r r8 r9 r: �len�left�rightr< �_create_stylesheet)�self�optionsr r r! r> � s$ zLatexFormatter.__init__c C s. t di }| _i }| _| j}dd� }| jD ]~\}}t|�}d}|d r(|d7 }|d r0|d7 }|d r8|d 7 }|d r@|d 7 }|d rH|d 7 }|d rP|d 7 }|d r^|d||d � 7 }|d rs|d||d �||d �f 7 }n|d r�|d||d � 7 }|dkr�q|�d|�}|||< |||< qd S )Nr# c s � rd� � fdd�dD ��S dS )N�,c s. g | ]}d t � | � |d d�d �qS )z%.2fr3 � g �o@)�int)�.0�i��colr r! � <listcomp> s &�zGLatexFormatter._create_stylesheet.<locals>.rgbcolor.<locals>.<listcomp>)r r; � z1,1,1)�joinrK r rK r! �rgbcolor s �z3LatexFormatter._create_stylesheet.<locals>.rgbcolor�boldz\let\$$@bf=\textbf�italicz\let\$$@it=\textit� underlinez\let\$$@ul=\underline�romanz\let\$$@ff=\textrm�sansz\let\$$@ff=\textsf�mono�colorz'\def\$$@tc##1{\textcolor[rgb]{%s}{##1}}�borderz\\def\$$@bc##1{{\setlength{\fboxsep}{\string -\fboxrule}\fcolorbox[rgb]{%s}{%s}{\strut ##1}}}�bgcolorzH\def\$$@bc##1{{\setlength{\fboxsep}{0pt}\colorbox[rgb]{%s}{\strut ##1}}}z$$)r � ttype2name�cmd2defr �styler* r ) rD �t2n�c2d�cprP r' �ndef�name�cmndefr r r! rC sN � �� � �z!LatexFormatter._create_stylesheetr# c C sH | j }g }| j�� D ]\}}|�d|||f � q t| j d�|�d� S )z� Return the command sequences needed to define the commands used to format text in the verbatim environment. ``arg`` is ignored. z\@namedef{%s@tok@%s}{%s}� )r_ �styles)r r[ �items�append�STYLE_TEMPLATErO )rD �argr_ rd ra � definitionr r r! �get_style_defs< s �z LatexFormatter.get_style_defsc C sj | j }| j}| jr|}t� }|�d| j d � | jr7| j| j}}|�d|r+d| p,d |r3d| p4d � | j s@| j s@| j rE|�d� | j rP|�d| j � |�d � |D �] \}} |t jv �r| j r�| d d � }td t| ��D ]} |d | | kr~ n|| | 7 }qr| t|�d � } t||�}|| } nu| j r�| �d �} d } t| �D ]\} } | s�t| |�| | < | } q�d �| �} nP| j r�| }d} |r�|�| j�\}}}|r�|�| j�\}}}|r�| t||�| 7 } n| t|| | |�7 } n| t||�7 } |s�nt| |�} n |t jv�r t| |�} g }|t u�r6z |�|| � W n t�y- |�t|�� Y nw |j }|t u�sd�t |��}|�rs| �d�}|d d� D ]}|�rZ|�d|||f � |�d� �qK|d �rr|�d|||d f � qW|�| � qW|�d| j d � | j�r�| j �p�d}dddd�� |� dd�|�}|�t!t"| j#| j$| j%|| �&� |�'� d� � d S d S )Nz\begin{z}[commandchars=\\\{\}z ,numbers=leftz,firstnumber=%dr# z,stepnumber=%dz6,codes={\catcode`\$=3\catcode`\^=7\catcode`\_=8\relax}rF z] r r3 r F�+rc r$ z \%s{%s}{%s}z\end{z} �utf8�latin1)�utf_8�latin_1� iso_8859_1r r )r. r0 �title�encoding� styledefs�code)(rZ r �fullr �writer< r1 r2 r4 r9 r8 r: r5 r �Comment�ranger@ r" �split� enumeraterO � partitionrA rB �Escaperf �KeyErrorr* r& �reversedrr r% r � DOC_TEMPLATE�dictr. r0 rq rj �getvalue)rD � tokensource�outfiler] r_ � realoutfile�start�stepr' �valuerJ �parts�in_math�partr �a�sep1�b�sep2rd �styleval�spl�linerr r r r! �format_unencodedH s� �� �� � � � ��� ��z LatexFormatter.format_unencodedN)r# ) �__name__� __module__� __qualname__�__doc__ra �aliases� filenamesr> rC rj r� r r r r! r � s a - c @ s8 e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd S ) �LatexEmbeddedLexera� This lexer takes one lexer as argument, the lexer for the language being formatted, and the left and right delimiters for escaped text. First everything is scanned using the language lexer to obtain strings and comments. All other consecutive tokens are merged and the resulting text is scanned for escaped segments, which are given the Token.Escape type. Finally text that is not escaped is scanned again with the language lexer. c K s( || _ || _|| _tj| fi |�� d S �N)rA rB �langr r> )rD rA rB r� rE r r r! r> � s zLatexEmbeddedLexer.__init__c C s� d}g }g }| � |�D ]#\}}}|d u r&|r!|�t|�|f� g }||7 }q |�|||f� q |r:|�t|�|f� t|| j�|��S )Nr# )�_find_safe_escape_tokensrf r@ r r� �get_tokens_unprocessed)rD r �buffered� insertions� insertion_bufrJ �t�vr r r! r� � s �z)LatexEmbeddedLexer.get_tokens_unprocessedc c sf � | � | j�|�dd� �D ]#\}}}|du r*| �|�D ] \}}}|| ||fV qq |d|fV q dS )z8 find escape tokens that are not in strings or comments c S s | t jv p | t jv S r� )r rw �String)r� r r r! �<lambda>� s z=LatexEmbeddedLexer._find_safe_escape_tokens.<locals>.<lambda>N)� _filter_tor� r� �_find_escape_tokens)rD r rJ r� r� �i2�t2�v2r r r! r� � s � ���z+LatexEmbeddedLexer._find_safe_escape_tokensc c sl � d}d}|D ]"\}}}||�r!|r|d|fV d}|||fV q|s%|}||7 }q|r4|d|fV dS dS )zC Keep only the tokens that match `pred`, merge the others together r# r Nr )rD �it�pred�buf�idxrJ r� r� r r r! r� � s � �z LatexEmbeddedLexer._filter_toc c s� � d}|rV|� | j�\}}}|r |d|fV |t|�7 }|rR|� | j�\}}}|rC|t|� tj|fV |t|�t|� t|� 7 }n|tj|fV |t|�7 }|}|sdS dS )z; Find escape tokens within text, give token=None otherwise r N)r{ rA r@ rB r r| �Error)rD r �indexr� r� r� r� r r r! r� � s � �z&LatexEmbeddedLexer._find_escape_tokensN) r� r� r� r� r> r� r� r� r� r r r r! r� � s r� N)r� �ior � pip._vendor.pygments.formatterr �pip._vendor.pygments.lexerr r �pip._vendor.pygments.tokenr r �pip._vendor.pygments.utilr r �__all__r" r rg r* r r� r r r r! �<module> s 7% PK J�ZDRSB� � ! __pycache__/groff.cpython-310.pycnu �[��� o �7]h� � @ sB d Z ddlZddlmZ ddlmZmZ dgZG dd� de�ZdS )z� pygments.formatters.groff ~~~~~~~~~~~~~~~~~~~~~~~~~ Formatter for groff output. :copyright: Copyright 2006-2021 by the Pygments team, see AUTHORS. :license: BSD, see LICENSE for details. � N)� Formatter)� get_bool_opt� get_int_opt�GroffFormatterc @ sX e Zd ZdZdZg d�Zg Zdd� Zdd� Zdd � Z d d � Z d d � Z dd� Z dd� Z dS )r a Format tokens with groff escapes to change their color and font style. .. versionadded:: 2.11 Additional options accepted: `style` The style to use, can be a string or a Style subclass (default: ``'default'``). `monospaced` If set to true, monospace font will be used (default: ``true``). `linenos` If set to true, print the line numbers (default: ``false``). `wrap` Wrap lines to the specified number of characters. Disabled if set to 0 (default: ``0``). �groff)r �troff�roffc K sZ t j| fi |�� t|dd�| _t|dd�| _d| _t|dd�| _d| _i | _ | � � d S )N� monospacedT�linenosFr �wrap) r �__init__r r r �_linenor r �_linelen�styles� _make_styles)�self�options� r �G/usr/lib/python3/dist-packages/pip/_vendor/pygments/formatters/groff.pyr - s zGroffFormatter.__init__c C s� | j rdnd}| j r dnd}| j rdnd}| jD ]G\}}d }}|d r0|d |d 7 }d | }|d r<||7 }|| }|d rH||7 }|| }|d rX|d|d 7 }d| }||f| j|< qd S )Nz\f[CR]z\f[R]z\f[CB]z\f[B]z\f[CI]z\f[I]� �colorz\m[%s]z\m[]�bold�italic�bgcolorz\M[%s]z\M[])r �styler )r �regularr r �ttype�ndef�start�endr r r r : s& �zGroffFormatter._make_stylesc C sX t � }| jD ]\}}|d d ur|�|d � q|D ]}|�d| d | d � qd S )Nr z .defcolor z rgb #� )�setr �add�write)r �outfile�colors�_r r r r r �_define_colorsQ s � �z GroffFormatter._define_colorsc C s4 | j d7 _ |�d| j dkrdpd| j f � d S )N� z%s% 4d r r )r r# )r r$ r r r � _write_lineno[ s &z GroffFormatter._write_linenoc C s� t |�d��}| jr dnd}d}|| jkrStdt�|| j ��D ]}||| j || j | j � }||d | 7 }q || j }|dkrQ||| d d � 7 }|| _|S | j| | jkrfd| | }|| _|S |}| j|7 _|S )Nr z r r r( )�len�rstripr r �range�math�floorr )r �line�length�space�newline�i�chunk� remainderr r r � _wrap_line` s& � �zGroffFormatter._wrap_linec C s� |� dd�� dd�� dd�� dd�� d d �}|}|D ]+}t|�t|�� �krE|�d ��� d d � � d d��� }|� |d|d d � d �}q|S )N�\z\[u005C]�.z \[char46]�'z\[u0027]�`z\[u0060]�~z\[u007E]�unicode_escaper( �x�u00z\[u�])�replacer* �encode�decode�upper)r �text�copy�char�unir r r � _escape_charsw s$ � �� �z GroffFormatter._escape_charsc C s� | � |� |�d� | jr| �|� |D ]]\}}| j| \}}|�d�D ]L}| jdkr0| �|�}|rL|rL| �|� d��}|dkrK|�d� |||f�� n |�| �|� d��� |� d�rp| jrh| �|� d| _ q$|�d� d| _ q$q|�d� d S )Nz .nf \f[CR] Tr r r z .fi) r' r# r r) r � splitlinesr r6 rH r+ �join�endswithr ) r � tokensourcer$ r �valuer r r/ rD r r r �format_unencoded� s0 � ��z GroffFormatter.format_unencodedN)�__name__� __module__� __qualname__�__doc__�name�aliases� filenamesr r r' r) r6 rH rN r r r r r s ) rR r- � pip._vendor.pygments.formatterr �pip._vendor.pygments.utilr r �__all__r r r r r �<module> s PK J�Z4��iq iq __pycache__/html.cpython-310.pycnu �[��� o �7]h� � @ s d Z ddlZddlZddlZddlZddlmZ ddlmZ ddl m Z m Z m Z ddl mZmZmZ zddlZW n eyC dZY nw dgZed�d ed �d ed �d ed�ded�diZefdd�Zdd� Zdd� ZdZde d ZdZd Z G d d� de�Z dS ) z� pygments.formatters.html ~~~~~~~~~~~~~~~~~~~~~~~~ Formatter for HTML output. :copyright: Copyright 2006-2021 by the Pygments team, see AUTHORS. :license: BSD, see LICENSE for details. � N)�StringIO)� Formatter)�Token�Text�STANDARD_TYPES)� get_bool_opt� get_int_opt� get_list_opt� HtmlFormatter�&z&�<z<�>z>�"z"�'z'c C s | � |�S )z<Escape &, <, > as well as single and double quotes for HTML.)� translate)�text�table� r �F/usr/lib/python3/dist-packages/pip/_vendor/pygments/formatters/html.py� escape_html& s r c C s | � d�s | � d�r | S d| S )N�calc�var�#)� startswith)�colorr r r �webify+ s r c C sN t �| �}|r |S d}|d u r#d| d | }| j} t �| �}|d u s|| S )N� �-���)r �get�parent)�ttype�fname�anamer r r �_get_ttype_class2 s �r$ z�/* generated by Pygments <https://pygments.org/> Copyright 2006-2021 by the Pygments team. Licensed under the BSD license, see LICENSE for details. */ %(styledefs)s a� <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd"> <!-- generated by Pygments <https://pygments.org/> Copyright 2006-2021 by the Pygments team. Licensed under the BSD license, see LICENSE for details. --> <html> <head> <title>%(title)s</title> <meta http-equiv="content-type" content="text/html; charset=%(encoding)s"> <style type="text/css"> z/ </style> </head> <body> <h2>%(title)s</h2> a5 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd"> <html> <head> <title>%(title)s</title> <meta http-equiv="content-type" content="text/html; charset=%(encoding)s"> <link rel="stylesheet" href="%(cssfile)s" type="text/css"> </head> <body> <h2>%(title)s</h2> z</body> </html> c @ s e Zd ZdZdZdgZddgZdd� Zdd � Zd d � Z d d � Z dd� Z dAdd�Z dAdd�Z dAdd�Zdd� Zdd� Zedd � �Zed d � �Zed d � �Zd!d"� Zd#d$� Zd%d&� Zd'd(� Zd)d*� Zd+d,� Zd-d.� Zd/d0� Z d1d2� Z e j d3d4�d5d6� �Z d7d8� Z!d9d:� Z"d;d<� Z#d=d>� Z$d?d@� Z%dS )Br aS, Format tokens as HTML 4 ``<span>`` tags within a ``<pre>`` tag, wrapped in a ``<div>`` tag. The ``<div>``'s CSS class can be set by the `cssclass` option. If the `linenos` option is set to ``"table"``, the ``<pre>`` is additionally wrapped inside a ``<table>`` which has one row and two cells: one containing the line numbers and one containing the code. Example: .. sourcecode:: html <div class="highlight" > <table><tr> <td class="linenos" title="click to toggle" onclick="with (this.firstChild.style) { display = (display == '') ? 'none' : '' }"> <pre>1 2</pre> </td> <td class="code"> <pre><span class="Ke">def </span><span class="NaFu">foo</span>(bar): <span class="Ke">pass</span> </pre> </td> </tr></table></div> (whitespace added to improve clarity). Wrapping can be disabled using the `nowrap` option. A list of lines can be specified using the `hl_lines` option to make these lines highlighted (as of Pygments 0.11). With the `full` option, a complete HTML 4 document is output, including the style definitions inside a ``<style>`` tag, or in a separate file if the `cssfile` option is given. When `tagsfile` is set to the path of a ctags index file, it is used to generate hyperlinks from names to their definition. You must enable `lineanchors` and run ctags with the `-n` option for this to work. The `python-ctags` module from PyPI must be installed to use this feature; otherwise a `RuntimeError` will be raised. The `get_style_defs(arg='')` method of a `HtmlFormatter` returns a string containing CSS rules for the CSS classes used by the formatter. The argument `arg` can be used to specify additional CSS selectors that are prepended to the classes. A call `fmter.get_style_defs('td .code')` would result in the following CSS classes: .. sourcecode:: css td .code .kw { font-weight: bold; color: #00FF00 } td .code .cm { color: #999999 } ... If you have Pygments 0.6 or higher, you can also pass a list or tuple to the `get_style_defs()` method to request multiple prefixes for the tokens: .. sourcecode:: python formatter.get_style_defs(['div.syntax pre', 'pre.syntax']) The output would then look like this: .. sourcecode:: css div.syntax pre .kw, pre.syntax .kw { font-weight: bold; color: #00FF00 } div.syntax pre .cm, pre.syntax .cm { color: #999999 } ... Additional options accepted: `nowrap` If set to ``True``, don't wrap the tokens at all, not even inside a ``<pre>`` tag. This disables most other options (default: ``False``). `full` Tells the formatter to output a "full" document, i.e. a complete self-contained document (default: ``False``). `title` If `full` is true, the title that should be used to caption the document (default: ``''``). `style` The style to use, can be a string or a Style subclass (default: ``'default'``). This option has no effect if the `cssfile` and `noclobber_cssfile` option are given and the file specified in `cssfile` exists. `noclasses` If set to true, token ``<span>`` tags (as well as line number elements) will not use CSS classes, but inline styles. This is not recommended for larger pieces of code since it increases output size by quite a bit (default: ``False``). `classprefix` Since the token types use relatively short class names, they may clash with some of your own class names. In this case you can use the `classprefix` option to give a string to prepend to all Pygments-generated CSS class names for token types. Note that this option also affects the output of `get_style_defs()`. `cssclass` CSS class for the wrapping ``<div>`` tag (default: ``'highlight'``). If you set this option, the default selector for `get_style_defs()` will be this class. .. versionadded:: 0.9 If you select the ``'table'`` line numbers, the wrapping table will have a CSS class of this string plus ``'table'``, the default is accordingly ``'highlighttable'``. `cssstyles` Inline CSS styles for the wrapping ``<div>`` tag (default: ``''``). `prestyles` Inline CSS styles for the ``<pre>`` tag (default: ``''``). .. versionadded:: 0.11 `cssfile` If the `full` option is true and this option is given, it must be the name of an external file. If the filename does not include an absolute path, the file's path will be assumed to be relative to the main output file's path, if the latter can be found. The stylesheet is then written to this file instead of the HTML file. .. versionadded:: 0.6 `noclobber_cssfile` If `cssfile` is given and the specified file exists, the css file will not be overwritten. This allows the use of the `full` option in combination with a user specified css file. Default is ``False``. .. versionadded:: 1.1 `linenos` If set to ``'table'``, output line numbers as a table with two cells, one containing the line numbers, the other the whole code. This is copy-and-paste-friendly, but may cause alignment problems with some browsers or fonts. If set to ``'inline'``, the line numbers will be integrated in the ``<pre>`` tag that contains the code (that setting is *new in Pygments 0.8*). For compatibility with Pygments 0.7 and earlier, every true value except ``'inline'`` means the same as ``'table'`` (in particular, that means also ``True``). The default value is ``False``, which means no line numbers at all. **Note:** with the default ("table") line number mechanism, the line numbers and code can have different line heights in Internet Explorer unless you give the enclosing ``<pre>`` tags an explicit ``line-height`` CSS property (you get the default line spacing with ``line-height: 125%``). `hl_lines` Specify a list of lines to be highlighted. The line numbers are always relative to the input (i.e. the first line is line 1) and are independent of `linenostart`. .. versionadded:: 0.11 `linenostart` The line number for the first line (default: ``1``). `linenostep` If set to a number n > 1, only every nth line number is printed. `linenospecial` If set to a number n > 0, every nth line number is given the CSS class ``"special"`` (default: ``0``). `nobackground` If set to ``True``, the formatter won't output the background color for the wrapping element (this automatically defaults to ``False`` when there is no wrapping element [eg: no argument for the `get_syntax_defs` method given]) (default: ``False``). .. versionadded:: 0.6 `lineseparator` This string is output between lines of code. It defaults to ``"\n"``, which is enough to break a line inside ``<pre>`` tags, but you can e.g. set it to ``"<br>"`` to get HTML line breaks. .. versionadded:: 0.7 `lineanchors` If set to a nonempty string, e.g. ``foo``, the formatter will wrap each output line in an anchor tag with an ``id`` (and `name`) of ``foo-linenumber``. This allows easy linking to certain lines. .. versionadded:: 0.9 `linespans` If set to a nonempty string, e.g. ``foo``, the formatter will wrap each output line in a span tag with an ``id`` of ``foo-linenumber``. This allows easy access to lines via javascript. .. versionadded:: 1.6 `anchorlinenos` If set to `True`, will wrap line numbers in <a> tags. Used in combination with `linenos` and `lineanchors`. `tagsfile` If set to the path of a ctags file, wrap names in anchor tags that link to their definitions. `lineanchors` should be used, and the tags file should specify line numbers (see the `-n` option to ctags). .. versionadded:: 1.6 `tagurlformat` A string formatting pattern used to generate links to ctags definitions. Available variables are `%(path)s`, `%(fname)s` and `%(fext)s`. Defaults to an empty string, resulting in just `#prefix-number` links. .. versionadded:: 1.6 `filename` A string used to generate a filename when rendering ``<pre>`` blocks, for example if displaying source code. If `linenos` is set to ``'table'`` then the filename will be rendered in an initial row containing a single `<th>` which spans both columns. .. versionadded:: 2.1 `wrapcode` Wrap the code inside ``<pre>`` blocks using ``<code>``, as recommended by the HTML5 specification. .. versionadded:: 2.4 `debug_token_types` Add ``title`` attributes to all token ``<span>`` tags that show the name of the token. .. versionadded:: 2.10 **Subclassing the HTML formatter** .. versionadded:: 0.7 The HTML formatter is now built in a way that allows easy subclassing, thus customizing the output HTML code. The `format()` method calls `self._format_lines()` which returns a generator that yields tuples of ``(1, line)``, where the ``1`` indicates that the ``line`` is a line of the formatted source code. If the `nowrap` option is set, the generator is the iterated over and the resulting HTML is output. Otherwise, `format()` calls `self.wrap()`, which wraps the generator with other generators. These may add some HTML code to the one generated by `_format_lines()`, either by modifying the lines generated by the latter, then yielding them again with ``(1, line)``, and/or by yielding other HTML code before or after the lines, with ``(0, html)``. The distinction between source lines and other code makes it possible to wrap the generator multiple times. The default `wrap()` implementation adds a ``<div>`` and a ``<pre>`` tag. A custom `HtmlFormatter` subclass could look like this: .. sourcecode:: python class CodeHtmlFormatter(HtmlFormatter): def wrap(self, source, outfile): return self._wrap_code(source) def _wrap_code(self, source): yield 0, '<code>' for i, t in source: if i == 1: # it's a line of formatted code t += '<br>' yield i, t yield 0, '</code>' This results in wrapping the formatted lines with a ``<code>`` tag, where the source lines are broken using ``<br>`` tags. After calling `wrap()`, the `format()` method also adds the "line numbers" and/or "full document" wrappers if the respective options are set. Then, all HTML yielded by the wrapped generator is output. �HTML�htmlz*.htmlz*.htmc K s t j| fi |�� | �| j�| _t|dd�| _t|dd�| _|�dd�| _| �|�dd��| _ | �|�dd��| _ | �|�d d��| _ | �|�d d��| _ t|d d�| _ | �|�d d��| _| �|�d d��| _| �|�dd��| _t|dd�| _i | _t|dd�| _| jr�ts�td��t�| j�| _|�dd�}|dkr�d| _n |r�d| _nd| _tt|dd��| _tt|dd��| _ tt|dd��| _ t|dd�| _ |�dd �| _ |�d d�| _ |�d d�| _!t|d d�| _"t#� | _$t%|d g �D ]}z | j$�&t'|�� W q� t(�y Y q�w | �)� d S )!N�nowrapF� noclasses� classprefixr �cssclass� highlight� cssstyles� prestyles�cssfile�noclobber_cssfile�tagsfile� tagurlformat�filename�wrapcode�debug_token_typeszRThe "ctags" package must to be installed to be able to use the "tagsfile" feature.�linenos�inline� � r � linenostart� linenostep� linenospecial� nobackground� lineseparator� � lineanchors� linespans� anchorlinenos�hl_lines)*r �__init__�_decodeifneeded�titler r' r( r r) r* r, r- r. r/ r0 r1 r2 r3 �span_element_openersr4 �ctags� RuntimeError�CTags�_ctagsr5 �absr r9 r: r; r< r= r? r@ rA �setrB r �add�int� ValueError�_create_stylesheet)�self�optionsr5 �linenor r r rC � sT � zHtmlFormatter.__init__c C s t |�}|r | j| S dS )zUReturn the css class of this token type prefixed with the classprefix option.r )r$ r) )rQ r! � ttypeclassr r r �_get_css_class� s z HtmlFormatter._get_css_classc C s: | � |�}|tvr|j}| � |�d | }|tvs |p dS )zOReturn the CSS classes of this token type prefixed with the classprefix option.� r )rU r r )rQ r! �clsr r r �_get_css_classes� s �z HtmlFormatter._get_css_classesc C s6 | j �|�}|du r|j}| j �|�}|du s |pdS )z1Return the inline CSS styles for this token type.Nr )� ttype2classr r )rQ r! �cclassr r r �_get_css_inline_styles� s �z$HtmlFormatter._get_css_inline_stylesc C s� t di }| _i }| _| jD ]`\}}| �|�}d}|d r(|dt|d � 7 }|d r0|d7 }|d r8|d7 }|d r@|d 7 }|d rN|d t|d � 7 }|d r\|d t|d � 7 }|ro|||< |d d� |t|�f||< qd S )Nr r z color: %s; �boldzfont-weight: bold; �italiczfont-style: italic; � underlinez text-decoration: underline; �bgcolorzbackground-color: %s; �borderzborder: 1px solid %s; ���)r rY � class2style�stylerU r �len)rQ �t2c�c2sr! �ndef�namerc r r r rP � s, ��z HtmlFormatter._create_stylesheetNc C s< g }|� | �� � |� | �|�� |� | �|�� d�|�S )z� Return CSS style definitions for the classes produced by the current highlighting style. ``arg`` can be a string or list of selectors to insert before the token type classes. r> )�extend�get_linenos_style_defs�get_background_style_defs�get_token_style_defs�join)rQ �arg� style_linesr r r �get_style_defs� s z HtmlFormatter.get_style_defsc s< | � |�� dd� | j�� D �}|�� � fdd�|D �}|S )Nc S s* g | ]\}\}}}|r|r||||f�qS r r )�.0rW rc r! �levelr r r � <listcomp> s �� �z6HtmlFormatter.get_token_style_defs.<locals>.<listcomp>c s2 g | ]\}}}}d � |�|t |�dd� f �qS )z%s { %s } /* %s */� N)�repr)rq rr r! rW rc ��prefixr r rs s ��)�get_css_prefixrb �items�sort)rQ rn �styles�linesr rv r rl s � �z"HtmlFormatter.get_token_style_defsc C s� | � |�}| jj}| jj}g }|r8| js8|d ur8d}t| jv r+d| j| jt d }|�dd|d�||f � |d urH|�dd|d�|f � |S )Nr rV r z%s{ background: %s;%s }z%s { background-color: %s }�hll) rx rc �background_color�highlight_colorr< r rY rb �insert)rQ rn rw �bg_color�hl_colorr| � text_styler r r rk s$ ���z'HtmlFormatter.get_background_style_defsc C s0 d| j d| j d| j d| j d| j g}|S )Nz pre { %s }ztd.linenos .normal { %s }zspan.linenos { %s }ztd.linenos .special { %s }zspan.linenos.special { %s })� _pre_style�_linenos_style�_linenos_special_style)rQ r| r r r rj 3 s �z$HtmlFormatter.get_linenos_style_defsc sJ |d u rd| j v rd| j pd}t|t�r|g� nt|�� � fdd�}|S )Nr* �.r c s> | rd| } g }� D ]}|� |r|d pd| � q d�|�S )Nr� rV r z, )�appendrm )rW �tmprn ��argsr r rw F s z,HtmlFormatter.get_css_prefix.<locals>.prefix)rR r* � isinstance�str�list)rQ rn rw r r� r rx > s z HtmlFormatter.get_css_prefixc C s dS )Nzline-height: 125%;r �rQ r r r r� P s zHtmlFormatter._pre_stylec C � d| j j| j jf S �NzGcolor: %s; background-color: %s; padding-left: 5px; padding-right: 5px;)rc �line_number_color� line_number_background_colorr� r r r r� T � �z HtmlFormatter._linenos_stylec C r� r� )rc �line_number_special_color�$line_number_special_background_colorr� r r r r� [ r� z$HtmlFormatter._linenos_special_stylec C s( t |t�r| jr|�| j�S |�� S |S �N)r� �bytes�encoding�decode�rQ �valuer r r rD b s z HtmlFormatter._decodeifneededc c sV � | j r�tj�| j �r| j }n/z|j}|r|d dkr t�tj�tj�|�| j �}W n ty= tdt j d� | j }Y nw z,tj� |�rH| j sit |d��}|�td| �d�i � W d � n1 sdw Y W n ty} } zd|j |_� d }~ww dtt| j| j | jd � fV ndtt| j| �d�| jd � fV |E d H dtfV d S ) Nr r z^Note: Cannot determine output file name, using current directory as base for the CSS file name)�file�w� styledefs�bodyzError writing CSS file: )rE r. r� )rE r� r� )r. �os�path�isabsrh �AttributeErrorrm �dirname�print�sys�stderr�existsr/ �open�write�CSSFILE_TEMPLATErp �OSError�strerror�DOC_HEADER_EXTERNALCSS�dictrE r� � DOC_HEADER� DOC_FOOTER)rQ �inner�outfile� cssfilenamer2 �cf�errr r r � _wrap_fulli sX �� � � � �� ��� ��� zHtmlFormatter._wrap_fullc c sj � t � }d}|D ]\}}|r|d7 }|�|� q| j}tt|| d ��}| j}| j} | j} | j} | j } g } t ||| �D ]J}|| dk}|oL|| dk}|r_d||f }| r^d| ||f }nd| }| rs|rmd| j }n d| j }n|rxd}nd}|r�d ||f }| � |� q=d �| �}d }| jr�d | j d }dd| j | d | d fV d|�� fV dV d S )Nr r8 �%*d�<a href="#%s-%d">%s</a>rV � style="%s"z class="special"z class="normal"�<span%s>%s</span>r> r zS<tr><th colspan="2" class="filename"><div class="highlight"><span class="filename">z</span></div></th></tr>z<table class="%stable">z4<tr><td class="linenos"><div class="linenodiv"><pre>z"</pre></div></td><td class="code">)r z</td></tr></table>)r r� r9 rd r� r; r: r? rA r( �ranger� r� r� rm r2 r* �getvalue)rQ r� � dummyoutfile�lncount�t�line�fl�mw�sp�st�la�aln�noclsr| �i� print_line� special_linerc �ls� filename_trr r r �_wrap_tablelinenos� sl � � ��� ���� z HtmlFormatter._wrap_tablelinenosc c s � t |�}| j}| j}| j}ttt|�| d ��}| j}| j}| j} |D ][\} } || dk} |o6|| dk} | r@d||f }nd| }| rT| rNd| j }n d| j }n| rYd}nd}|rdd||f }n|}|rudd |||f | fV nd|| fV |d7 }q%d S ) Nr8 r r� rV r� z class="linenos special"z class="linenos"r� r� ) r� r; r: r9 rd r� r? rA r( r� r� )rQ r� � inner_linesr� r� �numr� r� r� r� �_� inner_liner� r� r� rc r5 r r r �_wrap_inlinelinenos� s@ � � �z!HtmlFormatter._wrap_inlinelinenosc c sn � | j }| jd }|D ])\}}|r/|d7 }| jrdnd||f }dd|||||f | fV q d|fV q d S )Nr8 r z href="#%s-%d"z!<a id="%s-%d" name="%s-%d"%s></a>r )r? r9 r5 )rQ r� �sr� r� r� �hrefr r r �_wrap_lineanchors s � �z HtmlFormatter._wrap_lineanchorsc c sP � | j }| jd }|D ]\}}|r |d7 }dd|||f fV q d|fV q d S )Nr8 z<span id="%s-%d">%s</span>r )r@ r9 )rQ r� r� r� r� r� r r r �_wrap_linespans s � �z HtmlFormatter._wrap_linespansc c s� � g }| j r| js| jjd ur|�d| jjf � | jr"|�| j� d�|�}dd| jo0d| j |o6d| d fV |E d H dV d S ) Nzbackground: %s�; r z<divz class="%s"r� r )r z</div> )r( r< rc r~ r� r, rm r* �rQ r� rc r r r � _wrap_div s � �� zHtmlFormatter._wrap_divc c s� � g }| j r |�| j � | jr|�| j� d�|�}| jr,| jdkr,dd| j d fV dd|o3d| d fV |E d H d V d S ) Nr� r8 r z<span class="filename">�</span>z<prer� z><span></span>)r z</pre>)r- r� r( r� rm r2 r5 r� r r r � _wrap_pre$ s � zHtmlFormatter._wrap_prec c s � dV |E d H dV d S )N)r z<code>)r z</code>r )rQ r� r r r � _wrap_code5 s � zHtmlFormatter._wrap_code�d )�maxsizec C s |� t��d�S )z-HTML-escape a value and split it by newlines.r> )r �_escape_html_table�splitr� r r r �_translate_parts: s z HtmlFormatter._translate_partsc c s~ � | j }| j}| j}d}g }|D �]\}}z| j| } W nD ty` | jr-dd�|� nd} |rI| �|�} | rF| j| d } d| | f } nd} n| � |�} | rWd| | f } nd} | | j|< Y nw | � |�} |r�|t j v r�| � |�\}}|r�tj�|�\}}|r�|d7 }tj�|�\}}| j|||d� }d || j|| d f | d< | d d | d < | d d � D ]B}|r�|| kr�|�|o�d | || o�d |f� n |�||o�d |f� dd�|�fV g }q�|r�dd�| || o�d |f�fV q�d|fV q�|�r| d �r|| k�r|�|�od | | d f� | }q|�| d � q| d �r%| | d g}| }q|�r=|�|�o/d |f� dd�|�fV d S d S )zd Just format the tokens, without any wrapping tags. Yield individual lines. r z title="%s"r� r z<span style="%s"%s>z<span class="%s"%s>�/)r� r" �fextz<a href="%s#%s-%d">%sr z</a>Nr� r8 )r( r= r0 rF �KeyErrorr4 rm r[ rb rX r� r �Name� _lookup_ctagr� r� r� �splitextr1 r? ri r� )rQ � tokensourcer� �lsepr0 �lspanr� r! r� �cspanrE � css_style� css_class�partsr2 � linenumber�base� extension�url�partr r r � _format_lines? s~ � � ��� ��zHtmlFormatter._format_linesc C s0 t �� }| j�||�� d�r|d |d fS dS )Nr r� � lineNumber)NN)rG �TagEntryrJ �find�encode)rQ �token�entryr r r r� � s zHtmlFormatter._lookup_ctagc c s� � | j }t|�D ]>\}\}}|dkr||fV |d |v rA| jr9d}| jjdur/d| jjf }dd||f fV qdd| fV qd|fV qdS )z� Highlighted the lines specified in the `hl_lines` option by post-processing the token stream coming from `_format_lines`. r8 r Nz style="background-color: %s"r� z<span class="hll">%s</span>)rB � enumerater( rc r )rQ r� �hlsr� r� r� rc r r r �_highlight_lines� s � � �z HtmlFormatter._highlight_linesc C s, | j r| �| �| �|���S | �| �|��S )z� Wrap the ``source``, which is a generator yielding individual lines, in custom generators. See docstring for `format`. Can be overridden. )r3 r� r� r� )rQ �sourcer� r r r �wrap� s zHtmlFormatter.wrapc C s� | � |�}| js| jdkr| �|�}| jr| �|�}| jsF| jr%| �|�}| jr-| � |�}| � ||�}| jdkr=| � |�}| j rF| � ||�}|D ] \}}|�|� qHdS )aW The formatting process uses several nested generators; which of them are used is determined by the user's options. Each generator should take at least one argument, ``inner``, and wrap the pieces of text generated by this. Always yield 2-tuples: (code, text). If "code" is 1, the text is part of the original tokensource being highlighted, if it's 0, the text is some piece of wrapping. This makes it possible to use several different wrappers that process the original source linewise, e.g. line number generators. r7 r8 N)r� r' r5 r� rB r� r? r� r@ r� r r� �fullr� r� )rQ r� r� r r� �piecer r r �format_unencoded� s$ �z HtmlFormatter.format_unencodedr� )&�__name__� __module__� __qualname__�__doc__rh �aliases� filenamesrC rU rX r[ rP rp rl rk rj rx �propertyr� r� r� rD r� r� r� r� r� r� r� r� � functools� lru_cacher� r� r� r� r r r r r r r q sN (1 )C+ L ) r r r� r� �os.path�ior � pip._vendor.pygments.formatterr �pip._vendor.pygments.tokenr r r �pip._vendor.pygments.utilr r r rG � ImportError�__all__�ordr� r r r$ r� r� r� r� r r r r r �<module> sB �� � �PK J�Z ��;� � __pycache__/svg.cpython-310.pycnu �[��� o �7]h� � @ sR d Z ddlmZ ddlmZ ddlmZmZ dgZdd� Z i Z G dd� de�Z d S ) z� pygments.formatters.svg ~~~~~~~~~~~~~~~~~~~~~~~ Formatter for SVG output. :copyright: Copyright 2006-2021 by the Pygments team, see AUTHORS. :license: BSD, see LICENSE for details. � )� Formatter)�Comment)� get_bool_opt� get_int_opt� SvgFormatterc C s, | � dd�� dd�� dd�� dd�� d d �S ) z<Escape &, <, > as well as single and double quotes for HTML.�&z&�<z<�>z>�"z"�'z')�replace)�text� r �E/usr/lib/python3/dist-packages/pip/_vendor/pygments/formatters/svg.py� escape_html s �r c @ s8 e Zd ZdZdZdgZdgZdd� Zdd� Zd d � Z d S ) r a& Format tokens as an SVG graphics file. This formatter is still experimental. Each line of code is a ``<text>`` element with explicit ``x`` and ``y`` coordinates containing ``<tspan>`` elements with the individual token styles. By default, this formatter outputs a full SVG document including doctype declaration and the ``<svg>`` root element. .. versionadded:: 0.9 Additional options accepted: `nowrap` Don't wrap the SVG ``<text>`` elements in ``<svg><g>`` elements and don't add a XML declaration and a doctype. If true, the `fontfamily` and `fontsize` options are ignored. Defaults to ``False``. `fontfamily` The value to give the wrapping ``<g>`` element's ``font-family`` attribute, defaults to ``"monospace"``. `fontsize` The value to give the wrapping ``<g>`` element's ``font-size`` attribute, defaults to ``"14px"``. `linenos` If ``True``, add line numbers (default: ``False``). `linenostart` The line number for the first line (default: ``1``). `linenostep` If set to a number n > 1, only every nth line number is printed. `linenowidth` Maximum width devoted to line numbers (default: ``3*ystep``, sufficient for up to 4-digit line numbers. Increase width for longer code blocks). `xoffset` Starting offset in X direction, defaults to ``0``. `yoffset` Starting offset in Y direction, defaults to the font size if it is given in pixels, or ``20`` else. (This is necessary since text coordinates refer to the text baseline, not the top edge.) `ystep` Offset to add to the Y coordinate for each subsequent line. This should roughly be the text size plus 5. It defaults to that value if the text size is given in pixels, or ``25`` else. `spacehack` Convert spaces in the source to `` ``, which are non-breaking spaces. SVG provides the ``xml:space`` attribute to control how whitespace inside tags is handled, in theory, the ``preserve`` value could be used to keep all whitespace as-is. However, many current SVG viewers don't obey that rule, so this option is provided as a workaround and defaults to ``True``. �SVG�svgz*.svgc K s� t j| fi |�� t|dd�| _|�dd�| _|�dd�| _t|dd�| _| j� � }|� d �r7|d d � � � }zt |�}W n d }Y t|d |�| _ t|d |d �| _ t|dd�| _t|dd�| _t|dd�| _t|dd�| _t|dd| j �| _i | _d S )N�nowrapF� fontfamily� monospace�fontsize�14px�xoffsetr �px���� �yoffset�ystep� � spacehackT�linenos� linenostart� � linenostep� linenowidth� )r �__init__r r �getr r r r �strip�endswith�intr r r r r! r# r$ � _stylecache)�self�options�fs�int_fsr r r r& ] s& zSvgFormatter.__init__c C s� | j }| j}| js/| jr|�d| j � n|�d� |�d� |�d� |�d| j| jf � | j}| j}| � t �}|}| j r_|| dkrS|�d|| j |||f � || j | j 7 }|d7 }|�d ||f � |D ]x\} } | � | �} | r{d | d p|d } | r�d p�d } t| �} | jr�| �� �dd�} | �d�}|dd� D ]9}|�| | | � || j 7 }|�d� | j r�|| dkr�|�d|| j |||f � |d7 }|�d ||f � q�|�| |d | � qj|�d� | js�|�d� dS dS )z� Format ``tokensource``, an iterable of ``(tokentype, tokenstring)`` tuples and write it into ``outfile``. For our implementation we put all lines in their own 'line group'. z$<?xml version="1.0" encoding="%s"?> z<?xml version="1.0"?> zk<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.0//EN" "http://www.w3.org/TR/2001/REC-SVG-20010904/DTD/svg10.dtd"> z)<svg xmlns="http://www.w3.org/2000/svg"> z$<g font-family="%s" font-size="%s"> r z2<text x="%s" y="%s" %s text-anchor="end">%s</text>r" z)<text x="%s" y="%s" xml:space="preserve">z<tspanr � z</tspan>� z � N���z</text> z2<text x="%s" y="%s" text-anchor="end" %s>%s</text>z</text>z </g></svg> )r r r �encoding�writer r r! r# � _get_styler r r$ r r r � expandtabsr �split)r, � tokensource�outfile�x�y�counter� counter_step� counter_style�line_x�ttype�value�style�tspan�tspanend�parts�partr r r �format_unencodedr s` � � � � �z SvgFormatter.format_unencodedc C s� || j v r | j | S |}| j�|�s|j}| j�|�r| j�|�}d}|d r/d|d d }|d r7|d7 }|d r?|d7 }|| j |< |S ) Nr0 �colorz fill="#r �boldz font-weight="bold"�italicz font-style="italic")r+ rC � styles_token�parent�style_for_token)r, � tokentype� otokentyperB �resultr r r r6 � s � zSvgFormatter._get_styleN) �__name__� __module__� __qualname__�__doc__�name�aliases� filenamesr& rH r6 r r r r r s ; ;N) rU � pip._vendor.pygments.formatterr �pip._vendor.pygments.tokenr �pip._vendor.pygments.utilr r �__all__r � class2styler r r r r �<module> s PK J�Z)n ' __pycache__/pangomarkup.cpython-310.pycnu �[��� o �7]h� � @ sJ d Z ddlmZ dgZed�ded�diZefdd �ZG d d� de�Zd S ) z� pygments.formatters.pangomarkup ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Formatter for Pango markup output. :copyright: Copyright 2006-2021 by the Pygments team, see AUTHORS. :license: BSD, see LICENSE for details. � )� Formatter�PangoMarkupFormatter�&z&�<z<c C s | � |�S )z Escape & and < for Pango Markup.)� translate)�text�table� r �M/usr/lib/python3/dist-packages/pip/_vendor/pygments/formatters/pangomarkup.py�escape_special_chars s r c @ s0 e Zd ZdZdZddgZg Zdd� Zdd� Zd S ) r zk Format tokens as Pango Markup code. It can then be rendered to an SVG. .. versionadded:: 2.9 z Pango Markup�pango� pangomarkupc K s� t j| fi |�� i | _| jD ]C\}}d}d}|d r'|d|d 7 }d| }|d r3|d7 }d| }|d r?|d 7 }d | }|d rK|d 7 }d | }||f| j|< qd S )N� �colorz<span fgcolor="#%s">z</span>�boldz<b>z</b>�italicz<i>z</i>� underlinez<u>z</u>)r �__init__�styles�style)�self�options�tokenr �start�endr r r r ' s& �z PangoMarkupFormatter.__init__c C s� d}d }|� d� |D ]4\}}|| jvr |j}|| jvs||kr'|t|�7 }q |r9| j| \}}|� || | � t|�}|}q |rR| j| \}}|� || | � |� d� d S )Nr z<tt>z</tt>)�writer �parentr ) r � tokensource�outfile�lastval�lasttype�ttype�value� stylebegin�styleendr r r �format_unencoded= s$ �z%PangoMarkupFormatter.format_unencodedN) �__name__� __module__� __qualname__�__doc__�name�aliases� filenamesr r% r r r r r s N)r) � pip._vendor.pygments.formatterr �__all__�ord� _escape_tabler r r r r r �<module> s � PK J�ZF>��5D 5D __pycache__/img.cpython-310.pycnu �[��� o �7]h;U � @ sZ d Z ddlZddlZddlmZ ddlmZmZmZm Z ddl Z zddl m Z m Z mZ dZW n ey9 dZY nw zddlZW n ey[ zddlZW n eyX dZY nw Y nw g d�Zg d �d d gd gd dgd�ZdZdZdZG dd� de�ZG dd� de�ZG dd� d�ZG dd� de�Z G dd � d e �Z G d d � d e �Z G d d � d e �Z dS )!z� pygments.formatters.img ~~~~~~~~~~~~~~~~~~~~~~~ Formatter for Pixmap output. :copyright: Copyright 2006-2021 by the Pygments team, see AUTHORS. :license: BSD, see LICENSE for details. � N)� Formatter)� get_bool_opt� get_int_opt� get_list_opt�get_choice_opt)�Image� ImageDraw� ImageFontTF)�ImageFormatter�GifImageFormatter�JpgImageFormatter�BmpImageFormatter)� �Roman�Book�Normal�Regular�Medium�Oblique�Italic�Boldz Bold Obliquez Bold Italic)�NORMAL�ITALIC�BOLD� BOLDITALICzDejaVu Sans Monoz Courier New�Menloc @ � e Zd ZdZdS )�PilNotAvailablez,When Python imaging library is not availableN��__name__� __module__� __qualname__�__doc__� r# r# �E/usr/lib/python3/dist-packages/pip/_vendor/pygments/formatters/img.pyr 5 � r c @ r )� FontNotFoundz(When there are no usable fonts specifiedNr r# r# r# r$ r& 9 r% r& c @ sd e Zd ZdZddd�Zdd� Zdd� Zd d � Zd d � Zddd�Z dd� Z dd� Z dd� Z dd� Z dS )� FontManagerz> Manages a set of fonts: normal, italic, bold, etc... � c C sr || _ || _i | _d | _tj�d�r |st| _ | �� d S tj�d�r.|s(t | _ | � � d S |s3t | _ | � � d S )N�win�darwin) � font_name� font_size�fonts�encoding�sys�platform� startswith�DEFAULT_FONT_NAME_WIN� _create_win�DEFAULT_FONT_NAME_MAC� _create_mac�DEFAULT_FONT_NAME_NIX� _create_nix)�selfr+ r, r# r# r$ �__init__B s zFontManager.__init__c C sz t jdd||f dgt jd d�}|�� \}}|jdkr;|�� }|D ]}|�d�r)q!|�� �� �d�}|r8| S q!d S d S )Nzfc-listz %s:style=%s�file)�stdout�stderrr s Fontconfig warning:�:) � subprocess�Popen�PIPE� communicate� returncode� splitlinesr1 �decode�strip) r8 �name�style�procr; �_�lines�line�pathr# r# r$ �_get_nix_font_pathT s � ��z FontManager._get_nix_font_pathc C s� t d D ]}| �| j|�}|d ur t�|| j�| jd< nqtd| j ��dD ]5}t | D ]}| �| j|�}|d urFt�|| j�| j|< nq-|dkrT| jd | j|< q'| jd | j|< q'd S )Nr �No usable fonts named: "%s"�r r r r r )�STYLESrM r+ r �truetyper, r- r& )r8 rF rL rG � stylenamer# r# r$ r7 b s* �� ���zFontManager._create_nixc C s |� |d | �� �� �S )N� )�getrE �lower)r8 �font_maprF rG r# r# r$ �_get_mac_font_pathw s z FontManager._get_mac_font_pathc s i }t j�t �d�d�ddfD ]� |�� fdd�t �� �D �� qtd D ]}| �|| j|�}|d ur?t � || j �| j d< nq%t d| j ��d D ]6}t| D ]}| �|| j|�}|d urit � || j �| j |< nqO|d krw| j d | j |< qI| j d | j |< qId S ) N�HOMEzLibrary/Fonts/z/Library/Fonts/z/System/Library/Fonts/c 3 s@ � | ]}|� � �d �rtj�|�d � � tj�� |�fV qdS ))�ttf�ttcr N)rU �endswith�osrL �splitext�join)�.0�f��font_dirr# r$ � <genexpr>~ s � � �z*FontManager._create_mac.<locals>.<genexpr>r rN rO r r )r\ rL r^ �getenv�update�listdirrP rW r+ r rQ r, r- r& )r8 rV rF rL rG rR r# ra r$ r5 z s8 � � �� ���zFontManager._create_macFc C sv dD ]*}|D ]%}zd||od| |f }t �||�\}} |W S ty+ Y qw q|r9td||d f ��d S )N)r z (TrueType)z%s%s%srS z"Font %s (%s) not found in registryr )�_winreg� QueryValueEx�OSErrorr& ) r8 �key�basename�styles�fail�suffixrG �valname�valrI r# r# r$ � _lookup_win� s �� �zFontManager._lookup_winc C sJ d }t jdft jdft jdft jdfg}|D ]�}z{t j|� }zmzQ| �|| jtd d�}t�|| j �| j d< dD ].}| �|| jt| �}|rPt�|| j �| j |< q7|dkr]| j d | j |< q7| j d | j |< q7W W t � |� W d S t y� } z|}W Y d }~nd }~ww W t � |� nt � |� w W q t y� Y qw |r�|�t d��) Nz2Software\Microsoft\Windows NT\CurrentVersion\Fontsz/Software\Microsoft\Windows\CurrentVersion\Fontsr TrO r r z$Can't open Windows font registry key)rg �HKEY_CURRENT_USER�HKEY_LOCAL_MACHINE�OpenKeyrq r+ rP r rQ r, r- �CloseKeyr& ri )r8 � lookuperror�keynames�keynamerj rL rG �errr# r# r$ r3 � sB � ��� � zFontManager._create_winc C s | j d �d�S )z) Get the character size. r �M�r- �getsize�r8 r# r# r$ � get_char_size� � zFontManager.get_char_sizec C s | j d �|�S )z3 Get the text size(width, height). r r{ )r8 �textr# r# r$ � get_text_size� r zFontManager.get_text_sizec C s8 |r |r | j d S |r| j d S |r| j d S | j d S )z> Get the font based on bold and italic flags. r r r r )r- )r8 �bold�obliquer# r# r$ �get_font� s zFontManager.get_fontN)r( )F)r r r! r" r9 rM r7 rW r5 rq r3 r~ r� r� r# r# r# r$ r' = s ' r' c @ s� e Zd ZdZdZg d�ZdgZdZdZdd� Z d-d d �Z d d � Z dd� Z dd� Z dd� Zdd� Zdd� Zdd� Zdd� Zd d � Zd d � Zd d!� Zd"d#� Zd$d%� Zd&d'� Zd(d)� Zd*d+� Zd,S ).r a� Create a PNG image from source code. This uses the Python Imaging Library to generate a pixmap from the source code. .. versionadded:: 0.10 Additional options accepted: `image_format` An image format to output to that is recognised by PIL, these include: * "PNG" (default) * "JPEG" * "BMP" * "GIF" `line_pad` The extra spacing (in pixels) between each line of text. Default: 2 `font_name` The font name to be used as the base font from which others, such as bold and italic fonts will be generated. This really should be a monospace font to look sane. Default: "Courier New" on Windows, "Menlo" on Mac OS, and "DejaVu Sans Mono" on \*nix `font_size` The font size in points to be used. Default: 14 `image_pad` The padding, in pixels to be used at each edge of the resulting image. Default: 10 `line_numbers` Whether line numbers should be shown: True/False Default: True `line_number_start` The line number of the first line. Default: 1 `line_number_step` The step used when printing line numbers. Default: 1 `line_number_bg` The background colour (in "#123456" format) of the line number bar, or None to use the style background color. Default: "#eed" `line_number_fg` The text color of the line numbers (in "#123456"-like format). Default: "#886" `line_number_chars` The number of columns of line numbers allowable in the line number margin. Default: 2 `line_number_bold` Whether line numbers will be bold: True/False Default: False `line_number_italic` Whether line numbers will be italicized: True/False Default: False `line_number_separator` Whether a line will be drawn between the line number area and the source code area: True/False Default: True `line_number_pad` The horizontal padding (in pixels) between the line number margin, and the source code area. Default: 6 `hl_lines` Specify a list of lines to be highlighted. .. versionadded:: 1.2 Default: empty list `hl_color` Specify the color for highlighting lines. .. versionadded:: 1.2 Default: highlight color of the selected style �img)r� �IMG�pngz*.pngFr� c K s� t std��tj| fi |�� d| _t| j�| _| jjdu r"d| _n| jj| _t |dg d�| j dd�| _ t |d d �| _ t |d d �| _t |d d�}t|�dd�|�| _| j�� \| _| _|�dd�| _|�dd�| _t |dd �| _t|dd�| _t|dd�| _t |dd�| _t|dd�| _ t|d d�| _ t |d d �| _ t |d d �| _ | j r�| j| j | jd | _ nd | _ g | _!t"|d!g �}|D ]}z | j!�#t$|�� W q� t%y� Y q�w |�d"| jj&�p�d#| _'g | _(dS )$zE See the class docstring for explanation of options. z5Python Imaging Library is required for this formatter�latin1Nz#fff� image_format)r� �jpeg�gif�bmpT)�normcase� image_pad� �line_pad� r, r( r+ r �line_number_fgz#886�line_number_bgz#eed�line_number_chars�line_number_boldF�line_number_italic�line_number_pad� � line_numbers�line_number_separator�line_number_step� �line_number_startr �hl_lines�hl_colorz#f90))� pil_availabler r r9 r. �dictrG rl �background_colorr �default_image_formatr� r r� r� r' rT r- r~ �fontw�fonthr� r� r� r r� r� r� r� r� r� r� �line_number_widthr� r �append�int� ValueError�highlight_colorr� � drawables)r8 �options�fontsize� hl_lines_strrK r# r# r$ r9 ] sp � � ���� � ��� zImageFormatter.__init__r c C s t d��)NzWThe -S option is meaningless for the image formatter. Use -O style=<stylename> instead.)�NotImplementedError)r8 �argr# r# r$ �get_style_defs� s z ImageFormatter.get_style_defsc C s | j | j S )z+ Get the height of a line. )r� r� r} r# r# r$ �_get_line_height� s z ImageFormatter._get_line_heightc C s || � � | j S )z8 Get the Y coordinate of a line number. )r� r� �r8 �linenor# r# r$ � _get_line_y� s zImageFormatter._get_line_yc C s | j S )z/ Get the width of a character. )r� r} r# r# r$ �_get_char_width� s z ImageFormatter._get_char_widthc C s || j | j S )z? Get the X coordinate of a character position. )r� r� )r8 � linelengthr# r# r$ � _get_char_x� r zImageFormatter._get_char_xc C s | � |�| �|�fS )zL Get the actual position for a character and line position. )r� r� )r8 r� r� r# r# r$ � _get_text_pos� s z ImageFormatter._get_text_posc C s | j | �|�fS )zI Get the actual position for the start of a line number. )r� r� r� r# r# r$ �_get_linenumber_pos� r z"ImageFormatter._get_linenumber_posc C s$ |d durd|d }|S d}|S )zE Get the correct color for the token from the style. �colorN�#z#000r# )r8 rG �fillr# r# r$ �_get_text_color� � �z ImageFormatter._get_text_colorc C s$ |d durd|d }|S d}|S )zP Get the correct background color for the token from the style. �bgcolorNr� r# )r8 rG �bg_colorr# r# r$ �_get_text_bg_color� r� z!ImageFormatter._get_text_bg_colorc C s | j �|d |d �S )z5 Get the correct font for the style. r� �italic)r- r� )r8 rG r# r# r$ �_get_style_font� s z ImageFormatter._get_style_fontc C s$ | � |�| j | �|d �| j fS )z. Get the required image size. r )r� r� r� )r8 � maxlinelength� maxlinenor# r# r$ �_get_image_size� s �z ImageFormatter._get_image_sizec C s: | j | �|�t|��| j�| j�| j| j�| j dd� dS )zA Remember a line number drawable to paint later. N��font�text_fg�text_bg) � _draw_textr� �str�rjustr� r- r� r� r� r� )r8 �posnor� r# r# r$ �_draw_linenumber� s � �z ImageFormatter._draw_linenumberc C s | j �|||||f� dS )zB Remember a single drawable tuple to paint later. N)r� r� )r8 �posr� r� r� r� r# r# r$ r� � s zImageFormatter._draw_textc C s d } }}d }}|D ]p\}}|| j vr |j}|| j vs| j | } |�d�}|�d�} t| �D ]K\} } | �d�} | rn| j| �||�| | �| �| � | �| � | �d� | j � | �\}}||7 }t ||�}|t| �7 }t ||�}| �d�r{d}d}|d7 }q0q || _|| _|| _dS )z9 Create drawables for the token content. r � T� r� r� N)rl �parent� expandtabsrC � enumerate�rstripr� r� r� r� r� r- r� �max�lenr[ r� � maxcharnor� )r8 � tokensourcer� �charnor� r� r� �ttype�valuerG rJ �irK �temp� temp_width� temp_hightr# r# r$ �_create_drawables� sB � � �� z ImageFormatter._create_drawablesc C sB | j sdS t| j�D ]}|| j }|| j dkr | �||� q dS )z8 Create drawables for the line numbers. Nr )r� �ranger� r� r� r� )r8 �p�nr# r# r$ �_draw_line_numbers s ��z!ImageFormatter._draw_line_numbersc C s~ | j sdS | jdu r dS t�|�}|jd }| j| j | j }|jd||fg| j d� | j r<|j |df||fg| jd� ~dS )z@ Paint the line number background on the image. N���)r r �r� r ) r� r� r �Draw�sizer� r� r� � rectangler� r� rK )r8 �im�draw�recth�rectwr# r# r$ �_paint_line_number_bg$ s � z$ImageFormatter._paint_line_number_bgc C s8 | � |� | �� t�d| �| j| j�| j�}| �|� t � |�}| j rY| j | j | j d }| �� }|jd | }| j D ]}| �|d �} |j|| f|| | | fg| jd� q=| jD ]4\} } } } }|r�|j| | d�}|j| d | d | d |d | d |d g|d� |j| | | | d� q\|�|| j�� � dS )a Format ``tokensource``, an iterable of ``(tokentype, tokenstring)`` tuples and write it into ``outfile``. This implementation calculates where it should draw each token on the pixmap, then calculates the required pixmap size and draws the items. �RGBr� r r� )r� r� )r� r� N)r� r� r �newr� r� r� r� r� r r� r� r� r� r� r� r� r� r� r� r� �textsizer� �saver� �upper)r8 r� �outfiler� r� �xr� r� � linenumber�yr� r� r� r� r� � text_sizer# r# r$ �format5 s0 � �6zImageFormatter.formatN)r )r r r! r" rF �aliases� filenames� unicodeoutputr� r9 r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r# r# r# r$ r � s2 m 8 ( r c @ s$ e Zd ZdZdZdgZdgZdZdS )r z� Create a GIF image from source code. This uses the Python Imaging Library to generate a pixmap from the source code. .. versionadded:: 1.0 �img_gifr� z*.gifN�r r r! r" rF r� r� r� r# r# r# r$ r Z s r c @ s& e Zd ZdZdZddgZdgZdZdS )r z� Create a JPEG image from source code. This uses the Python Imaging Library to generate a pixmap from the source code. .. versionadded:: 1.0 �img_jpg�jpgr� z*.jpgNr r# r# r# r$ r h � r c @ s& e Zd ZdZdZddgZdgZdZdS )r z� Create a bitmap image from source code. This uses the Python Imaging Library to generate a pixmap from the source code. .. versionadded:: 1.0 �img_bmpr� �bitmapz*.bmpNr r# r# r# r$ r v r r ) r" r\ r/ � pip._vendor.pygments.formatterr �pip._vendor.pygments.utilr r r r r> �PILr r r r� � ImportErrorrg �winreg�__all__rP r6 r2 r4 r � Exceptionr& r' r r r r r# r# r# r$ �<module> sR � ���� + uPK J�Z�<X`� � " __pycache__/bbcode.cpython-310.pycnu �[��� o �7]h� � @ s6 d Z ddlmZ ddlmZ dgZG dd� de�ZdS )z� pygments.formatters.bbcode ~~~~~~~~~~~~~~~~~~~~~~~~~~ BBcode formatter. :copyright: Copyright 2006-2021 by the Pygments team, see AUTHORS. :license: BSD, see LICENSE for details. � )� Formatter)� get_bool_opt�BBCodeFormatterc @ s8 e Zd ZdZdZddgZg Zdd� Zdd� Zd d � Z d S ) r a� Format tokens with BBcodes. These formatting codes are used by many bulletin boards, so you can highlight your sourcecode with pygments before posting it there. This formatter has no support for background colors and borders, as there are no common BBcode tags for that. Some board systems (e.g. phpBB) don't support colors in their [code] tag, so you can't use the highlighting together with that tag. Text in a [code] tag usually is shown with a monospace font (which this formatter can do with the ``monofont`` option) and no spaces (which you need for indentation) are removed. Additional options accepted: `style` The style to use, can be a string or a Style subclass (default: ``'default'``). `codetag` If set to true, put the output into ``[code]`` tags (default: ``false``) `monofont` If set to true, add a tag to show the code with a monospace font (default: ``false``). �BBCode�bbcode�bbc K s@ t j| fi |�� t|dd�| _t|dd�| _i | _| �� d S )N�codetagF�monofont)r �__init__r �_code�_mono�styles� _make_styles)�self�options� r �H/usr/lib/python3/dist-packages/pip/_vendor/pygments/formatters/bbcode.pyr 3 s zBBCodeFormatter.__init__c C s� | j D ]C\}}d }}|d r|d|d 7 }d| }|d r'|d7 }d| }|d r3|d 7 }d | }|d r?|d 7 }d | }||f| j|< qd S )N� �colorz [color=#%s]z[/color]�boldz[b]z[/b]�italicz[i]z[/i]� underlinez[u]z[/u])�styler )r �ttype�ndef�start�endr r r r ; s �z BBCodeFormatter._make_stylesc C s� | j r|�d� | jr|�d� d}d }|D ]2\}}|| jvr'|j}|| jvs ||kr0||7 }q|rD| j| \}}|�d�|||f�� |}|}q|r]| j| \}}|�d�|||f�� | jre|�d� | j rm|�d� | j ss| jrz|�d� d S d S )Nz[code]z[font=monospace]r z[/font]z[/code]� )r �writer r �parent�join) r � tokensource�outfile�lastval�lasttyper �valuer r r r r �format_unencodedN s6 � �z BBCodeFormatter.format_unencodedN) �__name__� __module__� __qualname__�__doc__�name�aliases� filenamesr r r& r r r r r s N)r* � pip._vendor.pygments.formatterr �pip._vendor.pygments.utilr �__all__r r r r r �<module> s PK J�Z�^�� __pycache__/rtf.cpython-310.pycnu �[��� o �7]h� � @ s: d Z ddlmZ ddlmZmZ dgZG dd� de�ZdS )z� pygments.formatters.rtf ~~~~~~~~~~~~~~~~~~~~~~~ A formatter that generates RTF files. :copyright: Copyright 2006-2021 by the Pygments team, see AUTHORS. :license: BSD, see LICENSE for details. � )� Formatter)� get_int_opt� surrogatepair� RtfFormatterc @ s@ e Zd ZdZdZdgZdgZdd� Zdd� Zd d � Z d d � Z d S )r a� Format tokens as RTF markup. This formatter automatically outputs full RTF documents with color information and other useful stuff. Perfect for Copy and Paste into Microsoft(R) Word(R) documents. Please note that ``encoding`` and ``outencoding`` options are ignored. The RTF format is ASCII natively, but handles unicode characters correctly thanks to escape sequences. .. versionadded:: 0.6 Additional options accepted: `style` The style to use, can be a string or a Style subclass (default: ``'default'``). `fontface` The used font family, for example ``Bitstream Vera Sans``. Defaults to some generic font which is supposed to have fixed width. `fontsize` Size of the font used. Size is specified in half points. The default is 24 half-points, giving a size 12 font. .. versionadded:: 2.0 �RTF�rtfz*.rtfc K s4 t j| fi |�� |�d�pd| _t|dd�| _dS )a� Additional options accepted: ``fontface`` Name of the font used. Could for example be ``'Courier New'`` to further specify the default which is ``'\fmodern'``. The RTF specification claims that ``\fmodern`` are "Fixed-pitch serif and sans serif fonts". Hope every RTF implementation thinks the same about modern... �fontface� �fontsizer N)r �__init__�getr r r )�self�options� r �E/usr/lib/python3/dist-packages/pip/_vendor/pygments/formatters/rtf.pyr 2 s zRtfFormatter.__init__c C s |� dd�� dd�� dd�S )N�\z\\�{z\{�}z\})�replace)r �textr r r �_escapeB s �zRtfFormatter._escapec C s� |sdS | � |�}g }|D ]3}t|�}|dk r |�t|�� q d| kr)dk r3n n|�d| � q d|kr@|�dt|� � q d�|��dd�S )Nr � i z{\u%d}z {\u%d}{\u%d}� z\par )r �ord�append�strr �joinr )r r �buf�c�cnr r r � _escape_textG s �zRtfFormatter._escape_textc C s� |� d| jrd| �| j� pd � i }d}| jD ]?\}}|d |d |d fD ]/}|rW||vrW|||< |� dt|d d � d �t|d d � d �t|d d � d �f � |d7 }q(q|� d� | jri|� d| j � |D ]�\}} | j�|�s�|jr�|j}| j�|�s�|jsx| j�|�}g } |d r�| � d||d � |d r�| � d||d � |d r�| � d� |d r�| � d� |d r�| � d� |d r�| � d||d � d� | �} | r�|� d| � |� | � | �� | r�|� d� qk|� d� d S )NzJ{\rtf1\ansi\uc0\deff0{\fonttbl{\f0\fmodern\fprq1\fcharset0%s;}}{\colortbl;� r � �color�bgcolor�borderz\red%d\green%d\blue%d;r � � � � z}\f0 z\fs%dz\cb%dz\cf%d�boldz\b�italicz\i� underlinez\ulz\chbrdr\chcfpat%dz{%s r ) �writer r �style�intr � styles_token�parent�style_for_tokenr r r ) r � tokensource�outfile� color_mapping�offset�_r. r# �ttype�valuer �startr r r �format_unencoded_ sf �� ��� � � �z RtfFormatter.format_unencodedN) �__name__� __module__� __qualname__�__doc__�name�aliases� filenamesr r r r; r r r r r s N)r? � pip._vendor.pygments.formatterr �pip._vendor.pygments.utilr r �__all__r r r r r �<module> s PK J�Z�Q�{ { $ __pycache__/terminal.cpython-310.pycnu �[��� o �7]hB � @ s* d Z ddlmZ ddlmZmZmZmZmZm Z m Z m Z m Z m Z ddlmZ ddlmZ dgZi e d�e d�ed�ejd �ed �ejd �e jd �ejd �ejd �ejd �ejd�ejd �ejd�ej d�ej d�ej d �ej d�ede d e j de j!d e j"de j#de j$de jdedi �Z%G dd� de�Z&dS )z� pygments.formatters.terminal ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Formatter for terminal output with ANSI sequences. :copyright: Copyright 2006-2021 by the Pygments team, see AUTHORS. :license: BSD, see LICENSE for details. � )� Formatter) �Keyword�Name�Comment�String�Error�Number�Operator�Generic�Token� Whitespace)� ansiformat)�get_choice_opt�TerminalFormatter)� r )�gray� brightblack)�cyan� brightcyan)�blue� brightblue)�magenta� brightmagenta)�green� brightgreen)�_cyan_� _brightcyan_)�_green_� _brightgreen_)r r )�red� brightred)r r )�yellowr! )r r )�**r" )z *magenta*z*brightmagenta*)� _brightred_r# c @ sH e Zd ZdZdZddgZg Zdd� Zdd� Zd d � Z d d � Z d d� Z dS )r a� Format tokens with ANSI color sequences, for output in a text console. Color sequences are terminated at newlines, so that paging the output works correctly. The `get_style_defs()` method doesn't do anything special since there is no support for common styles. Options accepted: `bg` Set to ``"light"`` or ``"dark"`` depending on the terminal's background (default: ``"light"``). `colorscheme` A dictionary mapping token types to (lightbg, darkbg) color names or ``None`` (default: ``None`` = use builtin colorscheme). `linenos` Set to ``True`` to have line numbers on the terminal output as well (default: ``False`` = no line numbers). �Terminal�terminal�consolec K sT t j| fi |�� t|dddgd�dk| _|�dd �p t| _|�dd�| _d| _d S )N�bg�light�dark� colorscheme�linenosFr ) r �__init__r �darkbg�get�TERMINAL_COLORSr* r+ �_lineno)�self�options� r3 �J/usr/lib/python3/dist-packages/pip/_vendor/pygments/formatters/terminal.pyr, S s �� zTerminalFormatter.__init__c C s t �| ||�S �N)r �format)r1 � tokensource�outfiler3 r3 r4 r6 [ s zTerminalFormatter.formatc C s4 | j d7 _ |�d| j dkrdpd| j f � d S )N� z%s%04d: � r )r0 �write)r1 r8 r3 r3 r4 � _write_lineno^ s &z TerminalFormatter._write_linenoc C s8 | j �|�}|d u r|j}| j �|�}|d u s || j S r5 )r* r. �parentr- )r1 �ttype�colorsr3 r3 r4 � _get_colorb s � z TerminalFormatter._get_colorc C s� | j r| �|� |D ]:\}}| �|�}|�d�D ]+}|r(|�t||�d��� n|�|�d�� |�d�rC| j r>| �|� q|�d� qq | j rO|�d� d S d S )NTr: )r+ r< r@ � splitlinesr; r �rstrip�endswith)r1 r7 r8 r> �value�color�liner3 r3 r4 �format_unencodedl s" �� �z"TerminalFormatter.format_unencodedN) �__name__� __module__� __qualname__�__doc__�name�aliases� filenamesr, r6 r< r@ rG r3 r3 r3 r4 r 8 s N)'rK � pip._vendor.pygments.formatterr �pip._vendor.pygments.tokenr r r r r r r r r r � pip._vendor.pygments.consoler �pip._vendor.pygments.utilr �__all__�Preproc�Type�Word�Builtin�Function� Namespace�Class� Exception� Decorator�Variable�Constant� Attribute�Tag�Deleted�Inserted�Heading� Subheading�Promptr/ r r3 r3 r3 r4 �<module> sh 0 ������� � � � � �������!PK J�ZUF��# �# ' __pycache__/terminal256.cpython-310.pycnu �[��� o �7]h�- � @ sb d Z ddlmZ ddlmZ ddlmZ ddgZG dd� d�ZG d d� de�Z G d d� de �Z d S ) a� pygments.formatters.terminal256 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Formatter for 256-color terminal output with ANSI sequences. RGB-to-XTERM color conversion routines adapted from xterm256-conv tool (http://frexx.de/xterm-256-notes/data/xterm256-conv2.tar.bz2) by Wolfgang Frisch. Formatter version 1. :copyright: Copyright 2006-2021 by the Pygments team, see AUTHORS. :license: BSD, see LICENSE for details. � )� Formatter)�codes)� ansicolors�Terminal256Formatter�TerminalTrueColorFormatterc @ s6 e Zd Zd dd�Zdd� Zdd� Zd d � Zd d � ZdS )�EscapeSequenceNFc C s" || _ || _|| _|| _|| _d S �N)�fg�bg�bold� underline�italic)�selfr r r r r � r �M/usr/lib/python3/dist-packages/pip/_vendor/pygments/formatters/terminal256.py�__init__# s zEscapeSequence.__init__c C s t |�r dd�|� d S dS )Nz[�;�m� )�len�join�r �attrsr r r �escape* s zEscapeSequence.escapec C s� g }| j d ur1| j tv r&t| j �dd� }d|v r d| _|�|dd� � n |�ddd | j f� | jd ur_| jtv rTt| j�dd� }|�tt |dd� �d �� n |�d dd | j f� | jrg|�d � | j ro|�d � | j rw|�d� | � |�S )N�ansir z;01mT� � �38�5z%i� �48�01�04�03) r r r �replacer �append�extendr �str�intr r r )r r �escr r r � color_string/ s( zEscapeSequence.color_stringc C s� g }| j r |�ddt| j d �t| j d �t| j d �f� | jr:|�ddt| jd �t| jd �t| jd �f� | jrB|�d� | jrJ|�d� | jrR|�d � | �|�S ) Nr �2r � r r r! r" r# ) r r& r' r r r% r r r r r r r �true_color_stringI s 22 z EscapeSequence.true_color_stringc C sR g }| j d ur |�d� | jd ur|�d� | js | js | jr$|�d� | �|�S )N�39�49�00)r r% r r r r r r r r r � reset_stringW s zEscapeSequence.reset_string)NNFFF)�__name__� __module__� __qualname__r r r* r- r1 r r r r r " s r c @ s` e Zd ZdZdZg d�Zg Zdd� Zdd� Zdd � Z d d � Z d d � Z dd� Z dd� Z dd� ZdS )r a� Format tokens with ANSI color sequences, for output in a 256-color terminal or console. Like in `TerminalFormatter` color sequences are terminated at newlines, so that paging the output works correctly. The formatter takes colors from a style defined by the `style` option and converts them to nearest ANSI 256-color escape sequences. Bold and underline attributes from the style are preserved (and displayed). .. versionadded:: 0.9 .. versionchanged:: 2.2 If the used style defines foreground colors in the form ``#ansi*``, then `Terminal256Formatter` will map these to non extended foreground color. See :ref:`AnsiTerminalStyle` for more information. .. versionchanged:: 2.4 The ANSI color names have been updated with names that are easier to understand and align with colornames of other projects and terminals. See :ref:`this table <new-ansi-color-names>` for more information. Options accepted: `style` The style to use, can be a string or a Style subclass (default: ``'default'``). `linenos` Set to ``True`` to have line numbers on the terminal output as well (default: ``False`` = no line numbers). � Terminal256)� terminal256� console256�256c K sj t j| fi |�� g | _i | _i | _d|v| _d|v| _d|v| _| �� | � � |� dd�| _ d| _ d S )N�nobold� nounderline�noitalic�linenosFr ) r r � xterm_colors� best_match� style_string�usebold� useunderline� useitalic�_build_color_table� _setup_styles�getr< �_lineno)r �optionsr r r r � s z Terminal256Formatter.__init__c C sB | j �d� | j �d� | j �d� | j �d� | j �d� | j �d� | j �d� | j �d� | j �d � | j �d � | j �d � | j �d � | j �d � | j �d� | j �d� | j �d� d}td�D ]!}||d d }||d d }||d }| j �|||f� qftdd�D ]}d|d }| j �|||f� q�d S )N)r r r )�� r r )r rH r )rH rH r )r r �� )rH r rH )r rH rH )�� rJ rJ )� rK rK )� r r )r rL r )rL rL r )�\ rM rL )rL r rL )r rL rL )rL rL rL )r �_ � � �� rL �� �$ � r, � � r )r= r% �range)r � valuerange�i�r�g�b�vr r r rC � s4 �z'Terminal256Formatter._build_color_tablec C sr d}d}t dd�D ]-}| j| }||d }||d } ||d } || | | | | } | |k r6|}| }q |S )Ni r � r, r )rW r= ) r rZ r[ r\ �distance�matchrY �values�rd�gd�bd�dr r r �_closest_color� s �z#Terminal256Formatter._closest_colorc C s� | j �|d �}|tv r|}|| j |< |d u rGz tt|�d�}W n ty* d}Y nw |d? d@ }|d? d@ }|d@ }| �|||�}|| j |< |S )N� r rL rV )r> rE r r( r' � ValueErrorrf )r �color�index�rgbrZ r[ r\ r r r � _color_index� s � z!Terminal256Formatter._color_indexc C s� | j D ]d\}}t� }|d r| �|d �|_n |d r#| �|d �|_|d r0| �|d �|_n |d r<| �|d �|_| jrF|d rFd|_| jrP|d rPd|_| j rZ|d rZd|_ |� � |� � f| j t|�< qd S ) N� ansicolorri � bgansicolor�bgcolorr Tr r )�styler rl r r r@ r rA r rB r r* r1 r? r' �r �ttype�ndefr r r r rD � s( ��z"Terminal256Formatter._setup_stylesc C s4 | j d7 _ |�d| j dkrdpd| j f � d S )Nr, z%s%04d: � r )rF �write)r �outfiler r r � _write_lineno� s &z"Terminal256Formatter._write_linenoc C s t �| ||�S r )r �format)r � tokensourcerv r r r rx � s zTerminal256Formatter.formatc C s� | j r| �|� |D ]e\}}d}|rh|rhzC| jt|� \}}|�d�}|d d� D ]} | r6|�|| | � | j r?| �|� q)|�d� q)|d rT|�||d | � d}W n tyc |j}Y nw |rh|s|ro|�|� q | j rz|�d� d S d S )NTrt ���F)r< rw r? r' �splitru �KeyError�parent) r ry rv rr �value� not_found�on�off�spl�liner r r �format_unencoded� s6 �� ��z%Terminal256Formatter.format_unencodedN)r2 r3 r4 �__doc__�name�aliases� filenamesr rC rf rl rD rw rx r� r r r r r b s $ c @ s8 e Zd ZdZdZg d�Zg Zdd� Zdd� Zdd � Z d S ) r a} Format tokens with ANSI color sequences, for output in a true-color terminal or console. Like in `TerminalFormatter` color sequences are terminated at newlines, so that paging the output works correctly. .. versionadded:: 2.1 Options accepted: `style` The style to use, can be a string or a Style subclass (default: ``'default'``). �TerminalTrueColor)� terminal16m� console16m�16mc C s d S r r )r r r r rC 7 s z-TerminalTrueColorFormatter._build_color_tablec C sR z t t|�d�}W n ty Y d S w |d? d@ }|d? d@ }|d@ }|||fS )Nrg rL rV )r( r' rh )r ri rk rZ r[ r\ r r r � _color_tuple: s � z'TerminalTrueColorFormatter._color_tuplec C s� | j D ]J\}}t� }|d r| �|d �|_|d r"| �|d �|_| jr,|d r,d|_| jr6|d r6d|_| j r@|d r@d|_ |� � |� � f| j t|�< qd S )Nri ro r Tr r )rp r r� r r r@ r rA r rB r r- r1 r? r' rq r r r rD D s ��z(TerminalTrueColorFormatter._setup_stylesN) r2 r3 r4 r� r� r� r� rC r� rD r r r r r % s N) r� � pip._vendor.pygments.formatterr � pip._vendor.pygments.consoler �pip._vendor.pygments.styler �__all__r r r r r r r �<module> s @ DPK J�ZX%� � __pycache__/irc.cpython-310.pycnu �[��� o �7]h� � @ s� d Z ddlmZ ddlmZmZmZmZmZm Z m Z m Z m Z m Z ddlmZ dgZi e d�e d�ed�ejd�ed �ejd�e jd �ejd�ejd �ejd �ejd �ejd�ejd�ejd�ejd�ej d�ej d�ede d e j de j d e j de j!de jdedi�Z"i dd�dd�dd�dd �d d �d d �d!d"�d#d$�d%d$�d&d'�d(d)�d*d)�d+d,�d-d.�d/d.�d0d1�d2d3�d4d5d��Z#d6d7� Z$G d8d� de�Z%d9S ):z� pygments.formatters.irc ~~~~~~~~~~~~~~~~~~~~~~~ Formatter for IRC output :copyright: Copyright 2006-2021 by the Pygments team, see AUTHORS. :license: BSD, see LICENSE for details. � )� Formatter) �Keyword�Name�Comment�String�Error�Number�Operator�Generic�Token� Whitespace)�get_choice_opt� IRCFormatter)� r )�gray� brightblack)�cyan� brightcyan)�blue� brightblue)�magentar )�green� brightgreen)�_cyan_� _brightcyan_)�_green_� _brightgreen_)r r )�red� brightred)r r )�yellowr )r r )�**r )z *magenta*z*brightmagenta*)� _brightred_r! �white�black� r � r � r � r � r � �orange� r � brightyellow� � lightgreen� r r � � lightblue� r r � � brightmagenta� � � c C s� t | �dk r|S d }}d| v r |d7 }d| }| �d�} d| v r.|d7 }d| }| �d�} t | �dkrE|dtt| ��d � 7 }d| }|| | S ) Nr$ r �_� �*�r �r% )�len�strip�str� IRC_COLOR_MAP�zfill)�color�text�add�sub� rF �E/usr/lib/python3/dist-packages/pip/_vendor/pygments/formatters/irc.py� ircformatL s rH c @ s@ e Zd ZdZdZddgZg Zdd� Zdd� Zdd � Z d d � Z d S ) r aS Format tokens with IRC color sequences The `get_style_defs()` method doesn't do anything special since there is no support for common styles. Options accepted: `bg` Set to ``"light"`` or ``"dark"`` depending on the terminal's background (default: ``"light"``). `colorscheme` A dictionary mapping token types to (lightbg, darkbg) color names or ``None`` (default: ``None`` = use builtin colorscheme). `linenos` Set to ``True`` to have line numbers in the output as well (default: ``False`` = no line numbers). �IRC�ircc K sT t j| fi |�� t|dddgd�dk| _|�dd �p t| _|�dd�| _d| _d S )N�bg�light�dark� colorscheme�linenosFr ) r �__init__r �darkbg�get� IRC_COLORSrN rO �_lineno)�self�optionsrF rF rG rP z s �� zIRCFormatter.__init__c C s" | j d7 _ |�d| j � d S )Nr$ z %04d: )rT �write)rU �outfilerF rF rG � _write_lineno� s zIRCFormatter._write_linenoc C s� | � |� |D ]g\}}|�d�r| � |� |d d� }| j�|�}|d u r2|j}| j�|�}|d u s%|ri|| j }|�d�}|d d� D ]}| � |� |rY|�t||d d� �� qD|d rh|�t||d �� q|�|� q|�d� d S )N� ���) rY �endswithrN rR �parentrQ �splitrW rH �rU � tokensourcerX �ttype�valuerB �spl�linerF rF rG � _format_unencoded_with_lineno� s. � �� z*IRCFormatter._format_unencoded_with_linenoc C s� | j r | �||� d S |D ]V\}}| j�|�}|d u r+|d d� }| j�|�}|d u s|r^|| j }|�d�}|d d� D ]}|rI|�t||�� |�d� q=|d r]|�t||d �� q |�|� q d S )Nr[ rZ )rO re rN rR rQ r^ rW rH r_ rF rF rG �format_unencoded� s* � � �z IRCFormatter.format_unencodedN) �__name__� __module__� __qualname__�__doc__�name�aliases� filenamesrP rY re rf rF rF rF rG r a s N)&rj � pip._vendor.pygments.formatterr �pip._vendor.pygments.tokenr r r r r r r r r r �pip._vendor.pygments.utilr �__all__�Preproc�Type�Word�Builtin�Function� Namespace�Class� Exception� Decorator�Variable�Constant� Attribute�Tag�Deleted�Inserted�Heading� SubheadingrS r@ rH r rF rF rF rG �<module> s� 0 ������� � � � � ������� �������� � � � � ������PK J�ZWT��� � irc.pynu �[��� """ pygments.formatters.irc ~~~~~~~~~~~~~~~~~~~~~~~ Formatter for IRC output :copyright: Copyright 2006-2021 by the Pygments team, see AUTHORS. :license: BSD, see LICENSE for details. """ from pip._vendor.pygments.formatter import Formatter from pip._vendor.pygments.token import Keyword, Name, Comment, String, Error, \ Number, Operator, Generic, Token, Whitespace from pip._vendor.pygments.util import get_choice_opt __all__ = ['IRCFormatter'] #: Map token types to a tuple of color values for light and dark #: backgrounds. IRC_COLORS = { Token: ('', ''), Whitespace: ('gray', 'brightblack'), Comment: ('gray', 'brightblack'), Comment.Preproc: ('cyan', 'brightcyan'), Keyword: ('blue', 'brightblue'), Keyword.Type: ('cyan', 'brightcyan'), Operator.Word: ('magenta', 'brightcyan'), Name.Builtin: ('cyan', 'brightcyan'), Name.Function: ('green', 'brightgreen'), Name.Namespace: ('_cyan_', '_brightcyan_'), Name.Class: ('_green_', '_brightgreen_'), Name.Exception: ('cyan', 'brightcyan'), Name.Decorator: ('brightblack', 'gray'), Name.Variable: ('red', 'brightred'), Name.Constant: ('red', 'brightred'), Name.Attribute: ('cyan', 'brightcyan'), Name.Tag: ('brightblue', 'brightblue'), String: ('yellow', 'yellow'), Number: ('blue', 'brightblue'), Generic.Deleted: ('brightred', 'brightred'), Generic.Inserted: ('green', 'brightgreen'), Generic.Heading: ('**', '**'), Generic.Subheading: ('*magenta*', '*brightmagenta*'), Generic.Error: ('brightred', 'brightred'), Error: ('_brightred_', '_brightred_'), } IRC_COLOR_MAP = { 'white': 0, 'black': 1, 'blue': 2, 'brightgreen': 3, 'brightred': 4, 'yellow': 5, 'magenta': 6, 'orange': 7, 'green': 7, #compat w/ ansi 'brightyellow': 8, 'lightgreen': 9, 'brightcyan': 9, # compat w/ ansi 'cyan': 10, 'lightblue': 11, 'red': 11, # compat w/ ansi 'brightblue': 12, 'brightmagenta': 13, 'brightblack': 14, 'gray': 15, } def ircformat(color, text): if len(color) < 1: return text add = sub = '' if '_' in color: # italic add += '\x1D' sub = '\x1D' + sub color = color.strip('_') if '*' in color: # bold add += '\x02' sub = '\x02' + sub color = color.strip('*') # underline (\x1F) not supported # backgrounds (\x03FF,BB) not supported if len(color) > 0: # actual color - may have issues with ircformat("red", "blah")+"10" type stuff add += '\x03' + str(IRC_COLOR_MAP[color]).zfill(2) sub = '\x03' + sub return add + text + sub return '<'+add+'>'+text+'</'+sub+'>' class IRCFormatter(Formatter): r""" Format tokens with IRC color sequences The `get_style_defs()` method doesn't do anything special since there is no support for common styles. Options accepted: `bg` Set to ``"light"`` or ``"dark"`` depending on the terminal's background (default: ``"light"``). `colorscheme` A dictionary mapping token types to (lightbg, darkbg) color names or ``None`` (default: ``None`` = use builtin colorscheme). `linenos` Set to ``True`` to have line numbers in the output as well (default: ``False`` = no line numbers). """ name = 'IRC' aliases = ['irc', 'IRC'] filenames = [] def __init__(self, **options): Formatter.__init__(self, **options) self.darkbg = get_choice_opt(options, 'bg', ['light', 'dark'], 'light') == 'dark' self.colorscheme = options.get('colorscheme', None) or IRC_COLORS self.linenos = options.get('linenos', False) self._lineno = 0 def _write_lineno(self, outfile): self._lineno += 1 outfile.write("\n%04d: " % self._lineno) def _format_unencoded_with_lineno(self, tokensource, outfile): self._write_lineno(outfile) for ttype, value in tokensource: if value.endswith("\n"): self._write_lineno(outfile) value = value[:-1] color = self.colorscheme.get(ttype) while color is None: ttype = ttype.parent color = self.colorscheme.get(ttype) if color: color = color[self.darkbg] spl = value.split('\n') for line in spl[:-1]: self._write_lineno(outfile) if line: outfile.write(ircformat(color, line[:-1])) if spl[-1]: outfile.write(ircformat(color, spl[-1])) else: outfile.write(value) outfile.write("\n") def format_unencoded(self, tokensource, outfile): if self.linenos: self._format_unencoded_with_lineno(tokensource, outfile) return for ttype, value in tokensource: color = self.colorscheme.get(ttype) while color is None: ttype = ttype[:-1] color = self.colorscheme.get(ttype) if color: color = color[self.darkbg] spl = value.split('\n') for line in spl[:-1]: if line: outfile.write(ircformat(color, line)) outfile.write('\n') if spl[-1]: outfile.write(ircformat(color, spl[-1])) else: outfile.write(value) PK J�Z���}� � svg.pynu �[��� """ pygments.formatters.svg ~~~~~~~~~~~~~~~~~~~~~~~ Formatter for SVG output. :copyright: Copyright 2006-2021 by the Pygments team, see AUTHORS. :license: BSD, see LICENSE for details. """ from pip._vendor.pygments.formatter import Formatter from pip._vendor.pygments.token import Comment from pip._vendor.pygments.util import get_bool_opt, get_int_opt __all__ = ['SvgFormatter'] def escape_html(text): """Escape &, <, > as well as single and double quotes for HTML.""" return text.replace('&', '&'). \ replace('<', '<'). \ replace('>', '>'). \ replace('"', '"'). \ replace("'", ''') class2style = {} class SvgFormatter(Formatter): """ Format tokens as an SVG graphics file. This formatter is still experimental. Each line of code is a ``<text>`` element with explicit ``x`` and ``y`` coordinates containing ``<tspan>`` elements with the individual token styles. By default, this formatter outputs a full SVG document including doctype declaration and the ``<svg>`` root element. .. versionadded:: 0.9 Additional options accepted: `nowrap` Don't wrap the SVG ``<text>`` elements in ``<svg><g>`` elements and don't add a XML declaration and a doctype. If true, the `fontfamily` and `fontsize` options are ignored. Defaults to ``False``. `fontfamily` The value to give the wrapping ``<g>`` element's ``font-family`` attribute, defaults to ``"monospace"``. `fontsize` The value to give the wrapping ``<g>`` element's ``font-size`` attribute, defaults to ``"14px"``. `linenos` If ``True``, add line numbers (default: ``False``). `linenostart` The line number for the first line (default: ``1``). `linenostep` If set to a number n > 1, only every nth line number is printed. `linenowidth` Maximum width devoted to line numbers (default: ``3*ystep``, sufficient for up to 4-digit line numbers. Increase width for longer code blocks). `xoffset` Starting offset in X direction, defaults to ``0``. `yoffset` Starting offset in Y direction, defaults to the font size if it is given in pixels, or ``20`` else. (This is necessary since text coordinates refer to the text baseline, not the top edge.) `ystep` Offset to add to the Y coordinate for each subsequent line. This should roughly be the text size plus 5. It defaults to that value if the text size is given in pixels, or ``25`` else. `spacehack` Convert spaces in the source to `` ``, which are non-breaking spaces. SVG provides the ``xml:space`` attribute to control how whitespace inside tags is handled, in theory, the ``preserve`` value could be used to keep all whitespace as-is. However, many current SVG viewers don't obey that rule, so this option is provided as a workaround and defaults to ``True``. """ name = 'SVG' aliases = ['svg'] filenames = ['*.svg'] def __init__(self, **options): Formatter.__init__(self, **options) self.nowrap = get_bool_opt(options, 'nowrap', False) self.fontfamily = options.get('fontfamily', 'monospace') self.fontsize = options.get('fontsize', '14px') self.xoffset = get_int_opt(options, 'xoffset', 0) fs = self.fontsize.strip() if fs.endswith('px'): fs = fs[:-2].strip() try: int_fs = int(fs) except: int_fs = 20 self.yoffset = get_int_opt(options, 'yoffset', int_fs) self.ystep = get_int_opt(options, 'ystep', int_fs + 5) self.spacehack = get_bool_opt(options, 'spacehack', True) self.linenos = get_bool_opt(options,'linenos',False) self.linenostart = get_int_opt(options,'linenostart',1) self.linenostep = get_int_opt(options,'linenostep',1) self.linenowidth = get_int_opt(options,'linenowidth', 3*self.ystep) self._stylecache = {} def format_unencoded(self, tokensource, outfile): """ Format ``tokensource``, an iterable of ``(tokentype, tokenstring)`` tuples and write it into ``outfile``. For our implementation we put all lines in their own 'line group'. """ x = self.xoffset y = self.yoffset if not self.nowrap: if self.encoding: outfile.write('<?xml version="1.0" encoding="%s"?>\n' % self.encoding) else: outfile.write('<?xml version="1.0"?>\n') outfile.write('<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.0//EN" ' '"http://www.w3.org/TR/2001/REC-SVG-20010904/DTD/' 'svg10.dtd">\n') outfile.write('<svg xmlns="http://www.w3.org/2000/svg">\n') outfile.write('<g font-family="%s" font-size="%s">\n' % (self.fontfamily, self.fontsize)) counter = self.linenostart counter_step = self.linenostep counter_style = self._get_style(Comment) line_x = x if self.linenos: if counter % counter_step == 0: outfile.write('<text x="%s" y="%s" %s text-anchor="end">%s</text>' % (x+self.linenowidth,y,counter_style,counter)) line_x += self.linenowidth + self.ystep counter += 1 outfile.write('<text x="%s" y="%s" xml:space="preserve">' % (line_x, y)) for ttype, value in tokensource: style = self._get_style(ttype) tspan = style and '<tspan' + style + '>' or '' tspanend = tspan and '</tspan>' or '' value = escape_html(value) if self.spacehack: value = value.expandtabs().replace(' ', ' ') parts = value.split('\n') for part in parts[:-1]: outfile.write(tspan + part + tspanend) y += self.ystep outfile.write('</text>\n') if self.linenos and counter % counter_step == 0: outfile.write('<text x="%s" y="%s" text-anchor="end" %s>%s</text>' % (x+self.linenowidth,y,counter_style,counter)) counter += 1 outfile.write('<text x="%s" y="%s" ' 'xml:space="preserve">' % (line_x,y)) outfile.write(tspan + parts[-1] + tspanend) outfile.write('</text>') if not self.nowrap: outfile.write('</g></svg>\n') def _get_style(self, tokentype): if tokentype in self._stylecache: return self._stylecache[tokentype] otokentype = tokentype while not self.style.styles_token(tokentype): tokentype = tokentype.parent value = self.style.style_for_token(tokentype) result = '' if value['color']: result = ' fill="#' + value['color'] + '"' if value['bold']: result += ' font-weight="bold"' if value['italic']: result += ' font-style="italic"' self._stylecache[otokentype] = result return result PK J�Z��1J�- �- terminal256.pynu �[��� """ pygments.formatters.terminal256 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Formatter for 256-color terminal output with ANSI sequences. RGB-to-XTERM color conversion routines adapted from xterm256-conv tool (http://frexx.de/xterm-256-notes/data/xterm256-conv2.tar.bz2) by Wolfgang Frisch. Formatter version 1. :copyright: Copyright 2006-2021 by the Pygments team, see AUTHORS. :license: BSD, see LICENSE for details. """ # TODO: # - Options to map style's bold/underline/italic/border attributes # to some ANSI attrbutes (something like 'italic=underline') # - An option to output "style RGB to xterm RGB/index" conversion table # - An option to indicate that we are running in "reverse background" # xterm. This means that default colors are white-on-black, not # black-on-while, so colors like "white background" need to be converted # to "white background, black foreground", etc... from pip._vendor.pygments.formatter import Formatter from pip._vendor.pygments.console import codes from pip._vendor.pygments.style import ansicolors __all__ = ['Terminal256Formatter', 'TerminalTrueColorFormatter'] class EscapeSequence: def __init__(self, fg=None, bg=None, bold=False, underline=False, italic=False): self.fg = fg self.bg = bg self.bold = bold self.underline = underline self.italic = italic def escape(self, attrs): if len(attrs): return "\x1b[" + ";".join(attrs) + "m" return "" def color_string(self): attrs = [] if self.fg is not None: if self.fg in ansicolors: esc = codes[self.fg.replace('ansi','')] if ';01m' in esc: self.bold = True # extract fg color code. attrs.append(esc[2:4]) else: attrs.extend(("38", "5", "%i" % self.fg)) if self.bg is not None: if self.bg in ansicolors: esc = codes[self.bg.replace('ansi','')] # extract fg color code, add 10 for bg. attrs.append(str(int(esc[2:4])+10)) else: attrs.extend(("48", "5", "%i" % self.bg)) if self.bold: attrs.append("01") if self.underline: attrs.append("04") if self.italic: attrs.append("03") return self.escape(attrs) def true_color_string(self): attrs = [] if self.fg: attrs.extend(("38", "2", str(self.fg[0]), str(self.fg[1]), str(self.fg[2]))) if self.bg: attrs.extend(("48", "2", str(self.bg[0]), str(self.bg[1]), str(self.bg[2]))) if self.bold: attrs.append("01") if self.underline: attrs.append("04") if self.italic: attrs.append("03") return self.escape(attrs) def reset_string(self): attrs = [] if self.fg is not None: attrs.append("39") if self.bg is not None: attrs.append("49") if self.bold or self.underline or self.italic: attrs.append("00") return self.escape(attrs) class Terminal256Formatter(Formatter): """ Format tokens with ANSI color sequences, for output in a 256-color terminal or console. Like in `TerminalFormatter` color sequences are terminated at newlines, so that paging the output works correctly. The formatter takes colors from a style defined by the `style` option and converts them to nearest ANSI 256-color escape sequences. Bold and underline attributes from the style are preserved (and displayed). .. versionadded:: 0.9 .. versionchanged:: 2.2 If the used style defines foreground colors in the form ``#ansi*``, then `Terminal256Formatter` will map these to non extended foreground color. See :ref:`AnsiTerminalStyle` for more information. .. versionchanged:: 2.4 The ANSI color names have been updated with names that are easier to understand and align with colornames of other projects and terminals. See :ref:`this table <new-ansi-color-names>` for more information. Options accepted: `style` The style to use, can be a string or a Style subclass (default: ``'default'``). `linenos` Set to ``True`` to have line numbers on the terminal output as well (default: ``False`` = no line numbers). """ name = 'Terminal256' aliases = ['terminal256', 'console256', '256'] filenames = [] def __init__(self, **options): Formatter.__init__(self, **options) self.xterm_colors = [] self.best_match = {} self.style_string = {} self.usebold = 'nobold' not in options self.useunderline = 'nounderline' not in options self.useitalic = 'noitalic' not in options self._build_color_table() # build an RGB-to-256 color conversion table self._setup_styles() # convert selected style's colors to term. colors self.linenos = options.get('linenos', False) self._lineno = 0 def _build_color_table(self): # colors 0..15: 16 basic colors self.xterm_colors.append((0x00, 0x00, 0x00)) # 0 self.xterm_colors.append((0xcd, 0x00, 0x00)) # 1 self.xterm_colors.append((0x00, 0xcd, 0x00)) # 2 self.xterm_colors.append((0xcd, 0xcd, 0x00)) # 3 self.xterm_colors.append((0x00, 0x00, 0xee)) # 4 self.xterm_colors.append((0xcd, 0x00, 0xcd)) # 5 self.xterm_colors.append((0x00, 0xcd, 0xcd)) # 6 self.xterm_colors.append((0xe5, 0xe5, 0xe5)) # 7 self.xterm_colors.append((0x7f, 0x7f, 0x7f)) # 8 self.xterm_colors.append((0xff, 0x00, 0x00)) # 9 self.xterm_colors.append((0x00, 0xff, 0x00)) # 10 self.xterm_colors.append((0xff, 0xff, 0x00)) # 11 self.xterm_colors.append((0x5c, 0x5c, 0xff)) # 12 self.xterm_colors.append((0xff, 0x00, 0xff)) # 13 self.xterm_colors.append((0x00, 0xff, 0xff)) # 14 self.xterm_colors.append((0xff, 0xff, 0xff)) # 15 # colors 16..232: the 6x6x6 color cube valuerange = (0x00, 0x5f, 0x87, 0xaf, 0xd7, 0xff) for i in range(217): r = valuerange[(i // 36) % 6] g = valuerange[(i // 6) % 6] b = valuerange[i % 6] self.xterm_colors.append((r, g, b)) # colors 233..253: grayscale for i in range(1, 22): v = 8 + i * 10 self.xterm_colors.append((v, v, v)) def _closest_color(self, r, g, b): distance = 257*257*3 # "infinity" (>distance from #000000 to #ffffff) match = 0 for i in range(0, 254): values = self.xterm_colors[i] rd = r - values[0] gd = g - values[1] bd = b - values[2] d = rd*rd + gd*gd + bd*bd if d < distance: match = i distance = d return match def _color_index(self, color): index = self.best_match.get(color, None) if color in ansicolors: # strip the `ansi/#ansi` part and look up code index = color self.best_match[color] = index if index is None: try: rgb = int(str(color), 16) except ValueError: rgb = 0 r = (rgb >> 16) & 0xff g = (rgb >> 8) & 0xff b = rgb & 0xff index = self._closest_color(r, g, b) self.best_match[color] = index return index def _setup_styles(self): for ttype, ndef in self.style: escape = EscapeSequence() # get foreground from ansicolor if set if ndef['ansicolor']: escape.fg = self._color_index(ndef['ansicolor']) elif ndef['color']: escape.fg = self._color_index(ndef['color']) if ndef['bgansicolor']: escape.bg = self._color_index(ndef['bgansicolor']) elif ndef['bgcolor']: escape.bg = self._color_index(ndef['bgcolor']) if self.usebold and ndef['bold']: escape.bold = True if self.useunderline and ndef['underline']: escape.underline = True if self.useitalic and ndef['italic']: escape.italic = True self.style_string[str(ttype)] = (escape.color_string(), escape.reset_string()) def _write_lineno(self, outfile): self._lineno += 1 outfile.write("%s%04d: " % (self._lineno != 1 and '\n' or '', self._lineno)) def format(self, tokensource, outfile): return Formatter.format(self, tokensource, outfile) def format_unencoded(self, tokensource, outfile): if self.linenos: self._write_lineno(outfile) for ttype, value in tokensource: not_found = True while ttype and not_found: try: # outfile.write( "<" + str(ttype) + ">" ) on, off = self.style_string[str(ttype)] # Like TerminalFormatter, add "reset colors" escape sequence # on newline. spl = value.split('\n') for line in spl[:-1]: if line: outfile.write(on + line + off) if self.linenos: self._write_lineno(outfile) else: outfile.write('\n') if spl[-1]: outfile.write(on + spl[-1] + off) not_found = False # outfile.write( '#' + str(ttype) + '#' ) except KeyError: # ottype = ttype ttype = ttype.parent # outfile.write( '!' + str(ottype) + '->' + str(ttype) + '!' ) if not_found: outfile.write(value) if self.linenos: outfile.write("\n") class TerminalTrueColorFormatter(Terminal256Formatter): r""" Format tokens with ANSI color sequences, for output in a true-color terminal or console. Like in `TerminalFormatter` color sequences are terminated at newlines, so that paging the output works correctly. .. versionadded:: 2.1 Options accepted: `style` The style to use, can be a string or a Style subclass (default: ``'default'``). """ name = 'TerminalTrueColor' aliases = ['terminal16m', 'console16m', '16m'] filenames = [] def _build_color_table(self): pass def _color_tuple(self, color): try: rgb = int(str(color), 16) except ValueError: return None r = (rgb >> 16) & 0xff g = (rgb >> 8) & 0xff b = rgb & 0xff return (r, g, b) def _setup_styles(self): for ttype, ndef in self.style: escape = EscapeSequence() if ndef['color']: escape.fg = self._color_tuple(ndef['color']) if ndef['bgcolor']: escape.bg = self._color_tuple(ndef['bgcolor']) if self.usebold and ndef['bold']: escape.bold = True if self.useunderline and ndef['underline']: escape.underline = True if self.useitalic and ndef['italic']: escape.italic = True self.style_string[str(ttype)] = (escape.true_color_string(), escape.reset_string()) PK J�Zy�u/;U ;U img.pynu �[��� """ pygments.formatters.img ~~~~~~~~~~~~~~~~~~~~~~~ Formatter for Pixmap output. :copyright: Copyright 2006-2021 by the Pygments team, see AUTHORS. :license: BSD, see LICENSE for details. """ import os import sys from pip._vendor.pygments.formatter import Formatter from pip._vendor.pygments.util import get_bool_opt, get_int_opt, get_list_opt, \ get_choice_opt import subprocess # Import this carefully try: from PIL import Image, ImageDraw, ImageFont pil_available = True except ImportError: pil_available = False try: import _winreg except ImportError: try: import winreg as _winreg except ImportError: _winreg = None __all__ = ['ImageFormatter', 'GifImageFormatter', 'JpgImageFormatter', 'BmpImageFormatter'] # For some unknown reason every font calls it something different STYLES = { 'NORMAL': ['', 'Roman', 'Book', 'Normal', 'Regular', 'Medium'], 'ITALIC': ['Oblique', 'Italic'], 'BOLD': ['Bold'], 'BOLDITALIC': ['Bold Oblique', 'Bold Italic'], } # A sane default for modern systems DEFAULT_FONT_NAME_NIX = 'DejaVu Sans Mono' DEFAULT_FONT_NAME_WIN = 'Courier New' DEFAULT_FONT_NAME_MAC = 'Menlo' class PilNotAvailable(ImportError): """When Python imaging library is not available""" class FontNotFound(Exception): """When there are no usable fonts specified""" class FontManager: """ Manages a set of fonts: normal, italic, bold, etc... """ def __init__(self, font_name, font_size=14): self.font_name = font_name self.font_size = font_size self.fonts = {} self.encoding = None if sys.platform.startswith('win'): if not font_name: self.font_name = DEFAULT_FONT_NAME_WIN self._create_win() elif sys.platform.startswith('darwin'): if not font_name: self.font_name = DEFAULT_FONT_NAME_MAC self._create_mac() else: if not font_name: self.font_name = DEFAULT_FONT_NAME_NIX self._create_nix() def _get_nix_font_path(self, name, style): proc = subprocess.Popen(['fc-list', "%s:style=%s" % (name, style), 'file'], stdout=subprocess.PIPE, stderr=None) stdout, _ = proc.communicate() if proc.returncode == 0: lines = stdout.splitlines() for line in lines: if line.startswith(b'Fontconfig warning:'): continue path = line.decode().strip().strip(':') if path: return path return None def _create_nix(self): for name in STYLES['NORMAL']: path = self._get_nix_font_path(self.font_name, name) if path is not None: self.fonts['NORMAL'] = ImageFont.truetype(path, self.font_size) break else: raise FontNotFound('No usable fonts named: "%s"' % self.font_name) for style in ('ITALIC', 'BOLD', 'BOLDITALIC'): for stylename in STYLES[style]: path = self._get_nix_font_path(self.font_name, stylename) if path is not None: self.fonts[style] = ImageFont.truetype(path, self.font_size) break else: if style == 'BOLDITALIC': self.fonts[style] = self.fonts['BOLD'] else: self.fonts[style] = self.fonts['NORMAL'] def _get_mac_font_path(self, font_map, name, style): return font_map.get((name + ' ' + style).strip().lower()) def _create_mac(self): font_map = {} for font_dir in (os.path.join(os.getenv("HOME"), 'Library/Fonts/'), '/Library/Fonts/', '/System/Library/Fonts/'): font_map.update( (os.path.splitext(f)[0].lower(), os.path.join(font_dir, f)) for f in os.listdir(font_dir) if f.lower().endswith(('ttf', 'ttc'))) for name in STYLES['NORMAL']: path = self._get_mac_font_path(font_map, self.font_name, name) if path is not None: self.fonts['NORMAL'] = ImageFont.truetype(path, self.font_size) break else: raise FontNotFound('No usable fonts named: "%s"' % self.font_name) for style in ('ITALIC', 'BOLD', 'BOLDITALIC'): for stylename in STYLES[style]: path = self._get_mac_font_path(font_map, self.font_name, stylename) if path is not None: self.fonts[style] = ImageFont.truetype(path, self.font_size) break else: if style == 'BOLDITALIC': self.fonts[style] = self.fonts['BOLD'] else: self.fonts[style] = self.fonts['NORMAL'] def _lookup_win(self, key, basename, styles, fail=False): for suffix in ('', ' (TrueType)'): for style in styles: try: valname = '%s%s%s' % (basename, style and ' '+style, suffix) val, _ = _winreg.QueryValueEx(key, valname) return val except OSError: continue else: if fail: raise FontNotFound('Font %s (%s) not found in registry' % (basename, styles[0])) return None def _create_win(self): lookuperror = None keynames = [ (_winreg.HKEY_CURRENT_USER, r'Software\Microsoft\Windows NT\CurrentVersion\Fonts'), (_winreg.HKEY_CURRENT_USER, r'Software\Microsoft\Windows\CurrentVersion\Fonts'), (_winreg.HKEY_LOCAL_MACHINE, r'Software\Microsoft\Windows NT\CurrentVersion\Fonts'), (_winreg.HKEY_LOCAL_MACHINE, r'Software\Microsoft\Windows\CurrentVersion\Fonts') ] for keyname in keynames: try: key = _winreg.OpenKey(*keyname) try: path = self._lookup_win(key, self.font_name, STYLES['NORMAL'], True) self.fonts['NORMAL'] = ImageFont.truetype(path, self.font_size) for style in ('ITALIC', 'BOLD', 'BOLDITALIC'): path = self._lookup_win(key, self.font_name, STYLES[style]) if path: self.fonts[style] = ImageFont.truetype(path, self.font_size) else: if style == 'BOLDITALIC': self.fonts[style] = self.fonts['BOLD'] else: self.fonts[style] = self.fonts['NORMAL'] return except FontNotFound as err: lookuperror = err finally: _winreg.CloseKey(key) except OSError: pass else: # If we get here, we checked all registry keys and had no luck # We can be in one of two situations now: # * All key lookups failed. In this case lookuperror is None and we # will raise a generic error # * At least one lookup failed with a FontNotFound error. In this # case, we will raise that as a more specific error if lookuperror: raise lookuperror raise FontNotFound('Can\'t open Windows font registry key') def get_char_size(self): """ Get the character size. """ return self.fonts['NORMAL'].getsize('M') def get_text_size(self, text): """ Get the text size(width, height). """ return self.fonts['NORMAL'].getsize(text) def get_font(self, bold, oblique): """ Get the font based on bold and italic flags. """ if bold and oblique: return self.fonts['BOLDITALIC'] elif bold: return self.fonts['BOLD'] elif oblique: return self.fonts['ITALIC'] else: return self.fonts['NORMAL'] class ImageFormatter(Formatter): """ Create a PNG image from source code. This uses the Python Imaging Library to generate a pixmap from the source code. .. versionadded:: 0.10 Additional options accepted: `image_format` An image format to output to that is recognised by PIL, these include: * "PNG" (default) * "JPEG" * "BMP" * "GIF" `line_pad` The extra spacing (in pixels) between each line of text. Default: 2 `font_name` The font name to be used as the base font from which others, such as bold and italic fonts will be generated. This really should be a monospace font to look sane. Default: "Courier New" on Windows, "Menlo" on Mac OS, and "DejaVu Sans Mono" on \\*nix `font_size` The font size in points to be used. Default: 14 `image_pad` The padding, in pixels to be used at each edge of the resulting image. Default: 10 `line_numbers` Whether line numbers should be shown: True/False Default: True `line_number_start` The line number of the first line. Default: 1 `line_number_step` The step used when printing line numbers. Default: 1 `line_number_bg` The background colour (in "#123456" format) of the line number bar, or None to use the style background color. Default: "#eed" `line_number_fg` The text color of the line numbers (in "#123456"-like format). Default: "#886" `line_number_chars` The number of columns of line numbers allowable in the line number margin. Default: 2 `line_number_bold` Whether line numbers will be bold: True/False Default: False `line_number_italic` Whether line numbers will be italicized: True/False Default: False `line_number_separator` Whether a line will be drawn between the line number area and the source code area: True/False Default: True `line_number_pad` The horizontal padding (in pixels) between the line number margin, and the source code area. Default: 6 `hl_lines` Specify a list of lines to be highlighted. .. versionadded:: 1.2 Default: empty list `hl_color` Specify the color for highlighting lines. .. versionadded:: 1.2 Default: highlight color of the selected style """ # Required by the pygments mapper name = 'img' aliases = ['img', 'IMG', 'png'] filenames = ['*.png'] unicodeoutput = False default_image_format = 'png' def __init__(self, **options): """ See the class docstring for explanation of options. """ if not pil_available: raise PilNotAvailable( 'Python Imaging Library is required for this formatter') Formatter.__init__(self, **options) self.encoding = 'latin1' # let pygments.format() do the right thing # Read the style self.styles = dict(self.style) if self.style.background_color is None: self.background_color = '#fff' else: self.background_color = self.style.background_color # Image options self.image_format = get_choice_opt( options, 'image_format', ['png', 'jpeg', 'gif', 'bmp'], self.default_image_format, normcase=True) self.image_pad = get_int_opt(options, 'image_pad', 10) self.line_pad = get_int_opt(options, 'line_pad', 2) # The fonts fontsize = get_int_opt(options, 'font_size', 14) self.fonts = FontManager(options.get('font_name', ''), fontsize) self.fontw, self.fonth = self.fonts.get_char_size() # Line number options self.line_number_fg = options.get('line_number_fg', '#886') self.line_number_bg = options.get('line_number_bg', '#eed') self.line_number_chars = get_int_opt(options, 'line_number_chars', 2) self.line_number_bold = get_bool_opt(options, 'line_number_bold', False) self.line_number_italic = get_bool_opt(options, 'line_number_italic', False) self.line_number_pad = get_int_opt(options, 'line_number_pad', 6) self.line_numbers = get_bool_opt(options, 'line_numbers', True) self.line_number_separator = get_bool_opt(options, 'line_number_separator', True) self.line_number_step = get_int_opt(options, 'line_number_step', 1) self.line_number_start = get_int_opt(options, 'line_number_start', 1) if self.line_numbers: self.line_number_width = (self.fontw * self.line_number_chars + self.line_number_pad * 2) else: self.line_number_width = 0 self.hl_lines = [] hl_lines_str = get_list_opt(options, 'hl_lines', []) for line in hl_lines_str: try: self.hl_lines.append(int(line)) except ValueError: pass self.hl_color = options.get('hl_color', self.style.highlight_color) or '#f90' self.drawables = [] def get_style_defs(self, arg=''): raise NotImplementedError('The -S option is meaningless for the image ' 'formatter. Use -O style=<stylename> instead.') def _get_line_height(self): """ Get the height of a line. """ return self.fonth + self.line_pad def _get_line_y(self, lineno): """ Get the Y coordinate of a line number. """ return lineno * self._get_line_height() + self.image_pad def _get_char_width(self): """ Get the width of a character. """ return self.fontw def _get_char_x(self, linelength): """ Get the X coordinate of a character position. """ return linelength + self.image_pad + self.line_number_width def _get_text_pos(self, linelength, lineno): """ Get the actual position for a character and line position. """ return self._get_char_x(linelength), self._get_line_y(lineno) def _get_linenumber_pos(self, lineno): """ Get the actual position for the start of a line number. """ return (self.image_pad, self._get_line_y(lineno)) def _get_text_color(self, style): """ Get the correct color for the token from the style. """ if style['color'] is not None: fill = '#' + style['color'] else: fill = '#000' return fill def _get_text_bg_color(self, style): """ Get the correct background color for the token from the style. """ if style['bgcolor'] is not None: bg_color = '#' + style['bgcolor'] else: bg_color = None return bg_color def _get_style_font(self, style): """ Get the correct font for the style. """ return self.fonts.get_font(style['bold'], style['italic']) def _get_image_size(self, maxlinelength, maxlineno): """ Get the required image size. """ return (self._get_char_x(maxlinelength) + self.image_pad, self._get_line_y(maxlineno + 0) + self.image_pad) def _draw_linenumber(self, posno, lineno): """ Remember a line number drawable to paint later. """ self._draw_text( self._get_linenumber_pos(posno), str(lineno).rjust(self.line_number_chars), font=self.fonts.get_font(self.line_number_bold, self.line_number_italic), text_fg=self.line_number_fg, text_bg=None, ) def _draw_text(self, pos, text, font, text_fg, text_bg): """ Remember a single drawable tuple to paint later. """ self.drawables.append((pos, text, font, text_fg, text_bg)) def _create_drawables(self, tokensource): """ Create drawables for the token content. """ lineno = charno = maxcharno = 0 maxlinelength = linelength = 0 for ttype, value in tokensource: while ttype not in self.styles: ttype = ttype.parent style = self.styles[ttype] # TODO: make sure tab expansion happens earlier in the chain. It # really ought to be done on the input, as to do it right here is # quite complex. value = value.expandtabs(4) lines = value.splitlines(True) # print lines for i, line in enumerate(lines): temp = line.rstrip('\n') if temp: self._draw_text( self._get_text_pos(linelength, lineno), temp, font = self._get_style_font(style), text_fg = self._get_text_color(style), text_bg = self._get_text_bg_color(style), ) temp_width, temp_hight = self.fonts.get_text_size(temp) linelength += temp_width maxlinelength = max(maxlinelength, linelength) charno += len(temp) maxcharno = max(maxcharno, charno) if line.endswith('\n'): # add a line for each extra line in the value linelength = 0 charno = 0 lineno += 1 self.maxlinelength = maxlinelength self.maxcharno = maxcharno self.maxlineno = lineno def _draw_line_numbers(self): """ Create drawables for the line numbers. """ if not self.line_numbers: return for p in range(self.maxlineno): n = p + self.line_number_start if (n % self.line_number_step) == 0: self._draw_linenumber(p, n) def _paint_line_number_bg(self, im): """ Paint the line number background on the image. """ if not self.line_numbers: return if self.line_number_fg is None: return draw = ImageDraw.Draw(im) recth = im.size[-1] rectw = self.image_pad + self.line_number_width - self.line_number_pad draw.rectangle([(0, 0), (rectw, recth)], fill=self.line_number_bg) if self.line_number_separator: draw.line([(rectw, 0), (rectw, recth)], fill=self.line_number_fg) del draw def format(self, tokensource, outfile): """ Format ``tokensource``, an iterable of ``(tokentype, tokenstring)`` tuples and write it into ``outfile``. This implementation calculates where it should draw each token on the pixmap, then calculates the required pixmap size and draws the items. """ self._create_drawables(tokensource) self._draw_line_numbers() im = Image.new( 'RGB', self._get_image_size(self.maxlinelength, self.maxlineno), self.background_color ) self._paint_line_number_bg(im) draw = ImageDraw.Draw(im) # Highlight if self.hl_lines: x = self.image_pad + self.line_number_width - self.line_number_pad + 1 recth = self._get_line_height() rectw = im.size[0] - x for linenumber in self.hl_lines: y = self._get_line_y(linenumber - 1) draw.rectangle([(x, y), (x + rectw, y + recth)], fill=self.hl_color) for pos, value, font, text_fg, text_bg in self.drawables: if text_bg: text_size = draw.textsize(text=value, font=font) draw.rectangle([pos[0], pos[1], pos[0] + text_size[0], pos[1] + text_size[1]], fill=text_bg) draw.text(pos, value, font=font, fill=text_fg) im.save(outfile, self.image_format.upper()) # Add one formatter per format, so that the "-f gif" option gives the correct result # when used in pygmentize. class GifImageFormatter(ImageFormatter): """ Create a GIF image from source code. This uses the Python Imaging Library to generate a pixmap from the source code. .. versionadded:: 1.0 """ name = 'img_gif' aliases = ['gif'] filenames = ['*.gif'] default_image_format = 'gif' class JpgImageFormatter(ImageFormatter): """ Create a JPEG image from source code. This uses the Python Imaging Library to generate a pixmap from the source code. .. versionadded:: 1.0 """ name = 'img_jpg' aliases = ['jpg', 'jpeg'] filenames = ['*.jpg'] default_image_format = 'jpeg' class BmpImageFormatter(ImageFormatter): """ Create a bitmap image from source code. This uses the Python Imaging Library to generate a pixmap from the source code. .. versionadded:: 1.0 """ name = 'img_bmp' aliases = ['bmp', 'bitmap'] filenames = ['*.bmp'] default_image_format = 'bmp' PK J�Z�̠^� � bbcode.pynu �[��� """ pygments.formatters.bbcode ~~~~~~~~~~~~~~~~~~~~~~~~~~ BBcode formatter. :copyright: Copyright 2006-2021 by the Pygments team, see AUTHORS. :license: BSD, see LICENSE for details. """ from pip._vendor.pygments.formatter import Formatter from pip._vendor.pygments.util import get_bool_opt __all__ = ['BBCodeFormatter'] class BBCodeFormatter(Formatter): """ Format tokens with BBcodes. These formatting codes are used by many bulletin boards, so you can highlight your sourcecode with pygments before posting it there. This formatter has no support for background colors and borders, as there are no common BBcode tags for that. Some board systems (e.g. phpBB) don't support colors in their [code] tag, so you can't use the highlighting together with that tag. Text in a [code] tag usually is shown with a monospace font (which this formatter can do with the ``monofont`` option) and no spaces (which you need for indentation) are removed. Additional options accepted: `style` The style to use, can be a string or a Style subclass (default: ``'default'``). `codetag` If set to true, put the output into ``[code]`` tags (default: ``false``) `monofont` If set to true, add a tag to show the code with a monospace font (default: ``false``). """ name = 'BBCode' aliases = ['bbcode', 'bb'] filenames = [] def __init__(self, **options): Formatter.__init__(self, **options) self._code = get_bool_opt(options, 'codetag', False) self._mono = get_bool_opt(options, 'monofont', False) self.styles = {} self._make_styles() def _make_styles(self): for ttype, ndef in self.style: start = end = '' if ndef['color']: start += '[color=#%s]' % ndef['color'] end = '[/color]' + end if ndef['bold']: start += '[b]' end = '[/b]' + end if ndef['italic']: start += '[i]' end = '[/i]' + end if ndef['underline']: start += '[u]' end = '[/u]' + end # there are no common BBcodes for background-color and border self.styles[ttype] = start, end def format_unencoded(self, tokensource, outfile): if self._code: outfile.write('[code]') if self._mono: outfile.write('[font=monospace]') lastval = '' lasttype = None for ttype, value in tokensource: while ttype not in self.styles: ttype = ttype.parent if ttype == lasttype: lastval += value else: if lastval: start, end = self.styles[lasttype] outfile.write(''.join((start, lastval, end))) lastval = value lasttype = ttype if lastval: start, end = self.styles[lasttype] outfile.write(''.join((start, lastval, end))) if self._mono: outfile.write('[/font]') if self._code: outfile.write('[/code]') if self._code or self._mono: outfile.write('\n') PK J�ZV(��t t _mapping.pynu �[��� """ pygments.formatters._mapping ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Formatter mapping definitions. This file is generated by itself. Everytime you change something on a builtin formatter definition, run this script from the formatters folder to update it. Do not alter the FORMATTERS dictionary by hand. :copyright: Copyright 2006-2021 by the Pygments team, see AUTHORS. :license: BSD, see LICENSE for details. """ FORMATTERS = { 'BBCodeFormatter': ('pygments.formatters.bbcode', 'BBCode', ('bbcode', 'bb'), (), 'Format tokens with BBcodes. These formatting codes are used by many bulletin boards, so you can highlight your sourcecode with pygments before posting it there.'), 'BmpImageFormatter': ('pygments.formatters.img', 'img_bmp', ('bmp', 'bitmap'), ('*.bmp',), 'Create a bitmap image from source code. This uses the Python Imaging Library to generate a pixmap from the source code.'), 'GifImageFormatter': ('pygments.formatters.img', 'img_gif', ('gif',), ('*.gif',), 'Create a GIF image from source code. This uses the Python Imaging Library to generate a pixmap from the source code.'), 'GroffFormatter': ('pygments.formatters.groff', 'groff', ('groff', 'troff', 'roff'), (), 'Format tokens with groff escapes to change their color and font style.'), 'HtmlFormatter': ('pygments.formatters.html', 'HTML', ('html',), ('*.html', '*.htm'), "Format tokens as HTML 4 ``<span>`` tags within a ``<pre>`` tag, wrapped in a ``<div>`` tag. The ``<div>``'s CSS class can be set by the `cssclass` option."), 'IRCFormatter': ('pygments.formatters.irc', 'IRC', ('irc', 'IRC'), (), 'Format tokens with IRC color sequences'), 'ImageFormatter': ('pygments.formatters.img', 'img', ('img', 'IMG', 'png'), ('*.png',), 'Create a PNG image from source code. This uses the Python Imaging Library to generate a pixmap from the source code.'), 'JpgImageFormatter': ('pygments.formatters.img', 'img_jpg', ('jpg', 'jpeg'), ('*.jpg',), 'Create a JPEG image from source code. This uses the Python Imaging Library to generate a pixmap from the source code.'), 'LatexFormatter': ('pygments.formatters.latex', 'LaTeX', ('latex', 'tex'), ('*.tex',), 'Format tokens as LaTeX code. This needs the `fancyvrb` and `color` standard packages.'), 'NullFormatter': ('pygments.formatters.other', 'Text only', ('text', 'null'), ('*.txt',), 'Output the text unchanged without any formatting.'), 'PangoMarkupFormatter': ('pygments.formatters.pangomarkup', 'Pango Markup', ('pango', 'pangomarkup'), (), 'Format tokens as Pango Markup code. It can then be rendered to an SVG.'), 'RawTokenFormatter': ('pygments.formatters.other', 'Raw tokens', ('raw', 'tokens'), ('*.raw',), 'Format tokens as a raw representation for storing token streams.'), 'RtfFormatter': ('pygments.formatters.rtf', 'RTF', ('rtf',), ('*.rtf',), 'Format tokens as RTF markup. This formatter automatically outputs full RTF documents with color information and other useful stuff. Perfect for Copy and Paste into Microsoft(R) Word(R) documents.'), 'SvgFormatter': ('pygments.formatters.svg', 'SVG', ('svg',), ('*.svg',), 'Format tokens as an SVG graphics file. This formatter is still experimental. Each line of code is a ``<text>`` element with explicit ``x`` and ``y`` coordinates containing ``<tspan>`` elements with the individual token styles.'), 'Terminal256Formatter': ('pygments.formatters.terminal256', 'Terminal256', ('terminal256', 'console256', '256'), (), 'Format tokens with ANSI color sequences, for output in a 256-color terminal or console. Like in `TerminalFormatter` color sequences are terminated at newlines, so that paging the output works correctly.'), 'TerminalFormatter': ('pygments.formatters.terminal', 'Terminal', ('terminal', 'console'), (), 'Format tokens with ANSI color sequences, for output in a text console. Color sequences are terminated at newlines, so that paging the output works correctly.'), 'TerminalTrueColorFormatter': ('pygments.formatters.terminal256', 'TerminalTrueColor', ('terminal16m', 'console16m', '16m'), (), 'Format tokens with ANSI color sequences, for output in a true-color terminal or console. Like in `TerminalFormatter` color sequences are terminated at newlines, so that paging the output works correctly.'), 'TestcaseFormatter': ('pygments.formatters.other', 'Testcase', ('testcase',), (), 'Format tokens as appropriate for a new testcase.') } if __name__ == '__main__': # pragma: no cover import sys import os # lookup formatters found_formatters = [] imports = [] sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..', '..')) from pip._vendor.pygments.util import docstring_headline for root, dirs, files in os.walk('.'): for filename in files: if filename.endswith('.py') and not filename.startswith('_'): module_name = 'pygments.formatters%s.%s' % ( root[1:].replace('/', '.'), filename[:-3]) print(module_name) module = __import__(module_name, None, None, ['']) for formatter_name in module.__all__: formatter = getattr(module, formatter_name) found_formatters.append( '%r: %r' % (formatter_name, (module_name, formatter.name, tuple(formatter.aliases), tuple(formatter.filenames), docstring_headline(formatter)))) # sort them to make the diff minimal found_formatters.sort() # extract useful sourcecode from this file with open(__file__) as fp: content = fp.read() # replace crnl to nl for Windows. # # Note that, originally, contributers should keep nl of master # repository, for example by using some kind of automatic # management EOL, like `EolExtension # <https://www.mercurial-scm.org/wiki/EolExtension>`. content = content.replace("\r\n", "\n") header = content[:content.find('FORMATTERS = {')] footer = content[content.find("if __name__ == '__main__':"):] # write new file with open(__file__, 'w') as fp: fp.write(header) fp.write('FORMATTERS = {\n %s\n}\n\n' % ',\n '.join(found_formatters)) fp.write(footer) print ('=== %d formatters processed.' % len(found_formatters)) PK J�Z���B B terminal.pynu �[��� """ pygments.formatters.terminal ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Formatter for terminal output with ANSI sequences. :copyright: Copyright 2006-2021 by the Pygments team, see AUTHORS. :license: BSD, see LICENSE for details. """ from pip._vendor.pygments.formatter import Formatter from pip._vendor.pygments.token import Keyword, Name, Comment, String, Error, \ Number, Operator, Generic, Token, Whitespace from pip._vendor.pygments.console import ansiformat from pip._vendor.pygments.util import get_choice_opt __all__ = ['TerminalFormatter'] #: Map token types to a tuple of color values for light and dark #: backgrounds. TERMINAL_COLORS = { Token: ('', ''), Whitespace: ('gray', 'brightblack'), Comment: ('gray', 'brightblack'), Comment.Preproc: ('cyan', 'brightcyan'), Keyword: ('blue', 'brightblue'), Keyword.Type: ('cyan', 'brightcyan'), Operator.Word: ('magenta', 'brightmagenta'), Name.Builtin: ('cyan', 'brightcyan'), Name.Function: ('green', 'brightgreen'), Name.Namespace: ('_cyan_', '_brightcyan_'), Name.Class: ('_green_', '_brightgreen_'), Name.Exception: ('cyan', 'brightcyan'), Name.Decorator: ('brightblack', 'gray'), Name.Variable: ('red', 'brightred'), Name.Constant: ('red', 'brightred'), Name.Attribute: ('cyan', 'brightcyan'), Name.Tag: ('brightblue', 'brightblue'), String: ('yellow', 'yellow'), Number: ('blue', 'brightblue'), Generic.Deleted: ('brightred', 'brightred'), Generic.Inserted: ('green', 'brightgreen'), Generic.Heading: ('**', '**'), Generic.Subheading: ('*magenta*', '*brightmagenta*'), Generic.Prompt: ('**', '**'), Generic.Error: ('brightred', 'brightred'), Error: ('_brightred_', '_brightred_'), } class TerminalFormatter(Formatter): r""" Format tokens with ANSI color sequences, for output in a text console. Color sequences are terminated at newlines, so that paging the output works correctly. The `get_style_defs()` method doesn't do anything special since there is no support for common styles. Options accepted: `bg` Set to ``"light"`` or ``"dark"`` depending on the terminal's background (default: ``"light"``). `colorscheme` A dictionary mapping token types to (lightbg, darkbg) color names or ``None`` (default: ``None`` = use builtin colorscheme). `linenos` Set to ``True`` to have line numbers on the terminal output as well (default: ``False`` = no line numbers). """ name = 'Terminal' aliases = ['terminal', 'console'] filenames = [] def __init__(self, **options): Formatter.__init__(self, **options) self.darkbg = get_choice_opt(options, 'bg', ['light', 'dark'], 'light') == 'dark' self.colorscheme = options.get('colorscheme', None) or TERMINAL_COLORS self.linenos = options.get('linenos', False) self._lineno = 0 def format(self, tokensource, outfile): return Formatter.format(self, tokensource, outfile) def _write_lineno(self, outfile): self._lineno += 1 outfile.write("%s%04d: " % (self._lineno != 1 and '\n' or '', self._lineno)) def _get_color(self, ttype): # self.colorscheme is a dict containing usually generic types, so we # have to walk the tree of dots. The base Token type must be a key, # even if it's empty string, as in the default above. colors = self.colorscheme.get(ttype) while colors is None: ttype = ttype.parent colors = self.colorscheme.get(ttype) return colors[self.darkbg] def format_unencoded(self, tokensource, outfile): if self.linenos: self._write_lineno(outfile) for ttype, value in tokensource: color = self._get_color(ttype) for line in value.splitlines(True): if color: outfile.write(ansiformat(color, line.rstrip('\n'))) else: outfile.write(line.rstrip('\n')) if line.endswith('\n'): if self.linenos: self._write_lineno(outfile) else: outfile.write('\n') if self.linenos: outfile.write("\n") PK J�Z��܊� � pangomarkup.pynu �[��� """ pygments.formatters.pangomarkup ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Formatter for Pango markup output. :copyright: Copyright 2006-2021 by the Pygments team, see AUTHORS. :license: BSD, see LICENSE for details. """ from pip._vendor.pygments.formatter import Formatter __all__ = ['PangoMarkupFormatter'] _escape_table = { ord('&'): '&', ord('<'): '<', } def escape_special_chars(text, table=_escape_table): """Escape & and < for Pango Markup.""" return text.translate(table) class PangoMarkupFormatter(Formatter): """ Format tokens as Pango Markup code. It can then be rendered to an SVG. .. versionadded:: 2.9 """ name = 'Pango Markup' aliases = ['pango', 'pangomarkup'] filenames = [] def __init__(self, **options): Formatter.__init__(self, **options) self.styles = {} for token, style in self.style: start = '' end = '' if style['color']: start += '<span fgcolor="#%s">' % style['color'] end = '</span>' + end if style['bold']: start += '<b>' end = '</b>' + end if style['italic']: start += '<i>' end = '</i>' + end if style['underline']: start += '<u>' end = '</u>' + end self.styles[token] = (start, end) def format_unencoded(self, tokensource, outfile): lastval = '' lasttype = None outfile.write('<tt>') for ttype, value in tokensource: while ttype not in self.styles: ttype = ttype.parent if ttype == lasttype: lastval += escape_special_chars(value) else: if lastval: stylebegin, styleend = self.styles[lasttype] outfile.write(stylebegin + lastval + styleend) lastval = escape_special_chars(value) lasttype = ttype if lastval: stylebegin, styleend = self.styles[lasttype] outfile.write(stylebegin + lastval + styleend) outfile.write('</tt>') PK J�Z� �(�I �I latex.pynu �[��� """ pygments.formatters.latex ~~~~~~~~~~~~~~~~~~~~~~~~~ Formatter for LaTeX fancyvrb output. :copyright: Copyright 2006-2021 by the Pygments team, see AUTHORS. :license: BSD, see LICENSE for details. """ from io import StringIO from pip._vendor.pygments.formatter import Formatter from pip._vendor.pygments.lexer import Lexer, do_insertions from pip._vendor.pygments.token import Token, STANDARD_TYPES from pip._vendor.pygments.util import get_bool_opt, get_int_opt __all__ = ['LatexFormatter'] def escape_tex(text, commandprefix): return text.replace('\\', '\x00'). \ replace('{', '\x01'). \ replace('}', '\x02'). \ replace('\x00', r'\%sZbs{}' % commandprefix). \ replace('\x01', r'\%sZob{}' % commandprefix). \ replace('\x02', r'\%sZcb{}' % commandprefix). \ replace('^', r'\%sZca{}' % commandprefix). \ replace('_', r'\%sZus{}' % commandprefix). \ replace('&', r'\%sZam{}' % commandprefix). \ replace('<', r'\%sZlt{}' % commandprefix). \ replace('>', r'\%sZgt{}' % commandprefix). \ replace('#', r'\%sZsh{}' % commandprefix). \ replace('%', r'\%sZpc{}' % commandprefix). \ replace('$', r'\%sZdl{}' % commandprefix). \ replace('-', r'\%sZhy{}' % commandprefix). \ replace("'", r'\%sZsq{}' % commandprefix). \ replace('"', r'\%sZdq{}' % commandprefix). \ replace('~', r'\%sZti{}' % commandprefix) DOC_TEMPLATE = r''' \documentclass{%(docclass)s} \usepackage{fancyvrb} \usepackage{color} \usepackage[%(encoding)s]{inputenc} %(preamble)s %(styledefs)s \begin{document} \section*{%(title)s} %(code)s \end{document} ''' ## Small explanation of the mess below :) # # The previous version of the LaTeX formatter just assigned a command to # each token type defined in the current style. That obviously is # problematic if the highlighted code is produced for a different style # than the style commands themselves. # # This version works much like the HTML formatter which assigns multiple # CSS classes to each <span> tag, from the most specific to the least # specific token type, thus falling back to the parent token type if one # is not defined. Here, the classes are there too and use the same short # forms given in token.STANDARD_TYPES. # # Highlighted code now only uses one custom command, which by default is # \PY and selectable by the commandprefix option (and in addition the # escapes \PYZat, \PYZlb and \PYZrb which haven't been renamed for # backwards compatibility purposes). # # \PY has two arguments: the classes, separated by +, and the text to # render in that style. The classes are resolved into the respective # style commands by magic, which serves to ignore unknown classes. # # The magic macros are: # * \PY@it, \PY@bf, etc. are unconditionally wrapped around the text # to render in \PY@do. Their definition determines the style. # * \PY@reset resets \PY@it etc. to do nothing. # * \PY@toks parses the list of classes, using magic inspired by the # keyval package (but modified to use plusses instead of commas # because fancyvrb redefines commas inside its environments). # * \PY@tok processes one class, calling the \PY@tok@classname command # if it exists. # * \PY@tok@classname sets the \PY@it etc. to reflect the chosen style # for its class. # * \PY resets the style, parses the classnames and then calls \PY@do. # # Tip: to read this code, print it out in substituted form using e.g. # >>> print STYLE_TEMPLATE % {'cp': 'PY'} STYLE_TEMPLATE = r''' \makeatletter \def\%(cp)s@reset{\let\%(cp)s@it=\relax \let\%(cp)s@bf=\relax%% \let\%(cp)s@ul=\relax \let\%(cp)s@tc=\relax%% \let\%(cp)s@bc=\relax \let\%(cp)s@ff=\relax} \def\%(cp)s@tok#1{\csname %(cp)s@tok@#1\endcsname} \def\%(cp)s@toks#1+{\ifx\relax#1\empty\else%% \%(cp)s@tok{#1}\expandafter\%(cp)s@toks\fi} \def\%(cp)s@do#1{\%(cp)s@bc{\%(cp)s@tc{\%(cp)s@ul{%% \%(cp)s@it{\%(cp)s@bf{\%(cp)s@ff{#1}}}}}}} \def\%(cp)s#1#2{\%(cp)s@reset\%(cp)s@toks#1+\relax+\%(cp)s@do{#2}} %(styles)s \def\%(cp)sZbs{\char`\\} \def\%(cp)sZus{\char`\_} \def\%(cp)sZob{\char`\{} \def\%(cp)sZcb{\char`\}} \def\%(cp)sZca{\char`\^} \def\%(cp)sZam{\char`\&} \def\%(cp)sZlt{\char`\<} \def\%(cp)sZgt{\char`\>} \def\%(cp)sZsh{\char`\#} \def\%(cp)sZpc{\char`\%%} \def\%(cp)sZdl{\char`\$} \def\%(cp)sZhy{\char`\-} \def\%(cp)sZsq{\char`\'} \def\%(cp)sZdq{\char`\"} \def\%(cp)sZti{\char`\~} %% for compatibility with earlier versions \def\%(cp)sZat{@} \def\%(cp)sZlb{[} \def\%(cp)sZrb{]} \makeatother ''' def _get_ttype_name(ttype): fname = STANDARD_TYPES.get(ttype) if fname: return fname aname = '' while fname is None: aname = ttype[-1] + aname ttype = ttype.parent fname = STANDARD_TYPES.get(ttype) return fname + aname class LatexFormatter(Formatter): r""" Format tokens as LaTeX code. This needs the `fancyvrb` and `color` standard packages. Without the `full` option, code is formatted as one ``Verbatim`` environment, like this: .. sourcecode:: latex \begin{Verbatim}[commandchars=\\\{\}] \PY{k}{def }\PY{n+nf}{foo}(\PY{n}{bar}): \PY{k}{pass} \end{Verbatim} The special command used here (``\PY``) and all the other macros it needs are output by the `get_style_defs` method. With the `full` option, a complete LaTeX document is output, including the command definitions in the preamble. The `get_style_defs()` method of a `LatexFormatter` returns a string containing ``\def`` commands defining the macros needed inside the ``Verbatim`` environments. Additional options accepted: `style` The style to use, can be a string or a Style subclass (default: ``'default'``). `full` Tells the formatter to output a "full" document, i.e. a complete self-contained document (default: ``False``). `title` If `full` is true, the title that should be used to caption the document (default: ``''``). `docclass` If the `full` option is enabled, this is the document class to use (default: ``'article'``). `preamble` If the `full` option is enabled, this can be further preamble commands, e.g. ``\usepackage`` (default: ``''``). `linenos` If set to ``True``, output line numbers (default: ``False``). `linenostart` The line number for the first line (default: ``1``). `linenostep` If set to a number n > 1, only every nth line number is printed. `verboptions` Additional options given to the Verbatim environment (see the *fancyvrb* docs for possible values) (default: ``''``). `commandprefix` The LaTeX commands used to produce colored output are constructed using this prefix and some letters (default: ``'PY'``). .. versionadded:: 0.7 .. versionchanged:: 0.10 The default is now ``'PY'`` instead of ``'C'``. `texcomments` If set to ``True``, enables LaTeX comment lines. That is, LaTex markup in comment tokens is not escaped so that LaTeX can render it (default: ``False``). .. versionadded:: 1.2 `mathescape` If set to ``True``, enables LaTeX math mode escape in comments. That is, ``'$...$'`` inside a comment will trigger math mode (default: ``False``). .. versionadded:: 1.2 `escapeinside` If set to a string of length 2, enables escaping to LaTeX. Text delimited by these 2 characters is read as LaTeX code and typeset accordingly. It has no effect in string literals. It has no effect in comments if `texcomments` or `mathescape` is set. (default: ``''``). .. versionadded:: 2.0 `envname` Allows you to pick an alternative environment name replacing Verbatim. The alternate environment still has to support Verbatim's option syntax. (default: ``'Verbatim'``). .. versionadded:: 2.0 """ name = 'LaTeX' aliases = ['latex', 'tex'] filenames = ['*.tex'] def __init__(self, **options): Formatter.__init__(self, **options) self.docclass = options.get('docclass', 'article') self.preamble = options.get('preamble', '') self.linenos = get_bool_opt(options, 'linenos', False) self.linenostart = abs(get_int_opt(options, 'linenostart', 1)) self.linenostep = abs(get_int_opt(options, 'linenostep', 1)) self.verboptions = options.get('verboptions', '') self.nobackground = get_bool_opt(options, 'nobackground', False) self.commandprefix = options.get('commandprefix', 'PY') self.texcomments = get_bool_opt(options, 'texcomments', False) self.mathescape = get_bool_opt(options, 'mathescape', False) self.escapeinside = options.get('escapeinside', '') if len(self.escapeinside) == 2: self.left = self.escapeinside[0] self.right = self.escapeinside[1] else: self.escapeinside = '' self.envname = options.get('envname', 'Verbatim') self._create_stylesheet() def _create_stylesheet(self): t2n = self.ttype2name = {Token: ''} c2d = self.cmd2def = {} cp = self.commandprefix def rgbcolor(col): if col: return ','.join(['%.2f' % (int(col[i] + col[i + 1], 16) / 255.0) for i in (0, 2, 4)]) else: return '1,1,1' for ttype, ndef in self.style: name = _get_ttype_name(ttype) cmndef = '' if ndef['bold']: cmndef += r'\let\$$@bf=\textbf' if ndef['italic']: cmndef += r'\let\$$@it=\textit' if ndef['underline']: cmndef += r'\let\$$@ul=\underline' if ndef['roman']: cmndef += r'\let\$$@ff=\textrm' if ndef['sans']: cmndef += r'\let\$$@ff=\textsf' if ndef['mono']: cmndef += r'\let\$$@ff=\textsf' if ndef['color']: cmndef += (r'\def\$$@tc##1{\textcolor[rgb]{%s}{##1}}' % rgbcolor(ndef['color'])) if ndef['border']: cmndef += (r'\def\$$@bc##1{{\setlength{\fboxsep}{\string -\fboxrule}' r'\fcolorbox[rgb]{%s}{%s}{\strut ##1}}}' % (rgbcolor(ndef['border']), rgbcolor(ndef['bgcolor']))) elif ndef['bgcolor']: cmndef += (r'\def\$$@bc##1{{\setlength{\fboxsep}{0pt}' r'\colorbox[rgb]{%s}{\strut ##1}}}' % rgbcolor(ndef['bgcolor'])) if cmndef == '': continue cmndef = cmndef.replace('$$', cp) t2n[ttype] = name c2d[name] = cmndef def get_style_defs(self, arg=''): """ Return the command sequences needed to define the commands used to format text in the verbatim environment. ``arg`` is ignored. """ cp = self.commandprefix styles = [] for name, definition in self.cmd2def.items(): styles.append(r'\@namedef{%s@tok@%s}{%s}' % (cp, name, definition)) return STYLE_TEMPLATE % {'cp': self.commandprefix, 'styles': '\n'.join(styles)} def format_unencoded(self, tokensource, outfile): # TODO: add support for background colors t2n = self.ttype2name cp = self.commandprefix if self.full: realoutfile = outfile outfile = StringIO() outfile.write('\\begin{' + self.envname + '}[commandchars=\\\\\\{\\}') if self.linenos: start, step = self.linenostart, self.linenostep outfile.write(',numbers=left' + (start and ',firstnumber=%d' % start or '') + (step and ',stepnumber=%d' % step or '')) if self.mathescape or self.texcomments or self.escapeinside: outfile.write(',codes={\\catcode`\\$=3\\catcode`\\^=7' '\\catcode`\\_=8\\relax}') if self.verboptions: outfile.write(',' + self.verboptions) outfile.write(']\n') for ttype, value in tokensource: if ttype in Token.Comment: if self.texcomments: # Try to guess comment starting lexeme and escape it ... start = value[0:1] for i in range(1, len(value)): if start[0] != value[i]: break start += value[i] value = value[len(start):] start = escape_tex(start, cp) # ... but do not escape inside comment. value = start + value elif self.mathescape: # Only escape parts not inside a math environment. parts = value.split('$') in_math = False for i, part in enumerate(parts): if not in_math: parts[i] = escape_tex(part, cp) in_math = not in_math value = '$'.join(parts) elif self.escapeinside: text = value value = '' while text: a, sep1, text = text.partition(self.left) if sep1: b, sep2, text = text.partition(self.right) if sep2: value += escape_tex(a, cp) + b else: value += escape_tex(a + sep1 + b, cp) else: value += escape_tex(a, cp) else: value = escape_tex(value, cp) elif ttype not in Token.Escape: value = escape_tex(value, cp) styles = [] while ttype is not Token: try: styles.append(t2n[ttype]) except KeyError: # not in current style styles.append(_get_ttype_name(ttype)) ttype = ttype.parent styleval = '+'.join(reversed(styles)) if styleval: spl = value.split('\n') for line in spl[:-1]: if line: outfile.write("\\%s{%s}{%s}" % (cp, styleval, line)) outfile.write('\n') if spl[-1]: outfile.write("\\%s{%s}{%s}" % (cp, styleval, spl[-1])) else: outfile.write(value) outfile.write('\\end{' + self.envname + '}\n') if self.full: encoding = self.encoding or 'utf8' # map known existings encodings from LaTeX distribution encoding = { 'utf_8': 'utf8', 'latin_1': 'latin1', 'iso_8859_1': 'latin1', }.get(encoding.replace('-', '_'), encoding) realoutfile.write(DOC_TEMPLATE % dict(docclass = self.docclass, preamble = self.preamble, title = self.title, encoding = encoding, styledefs = self.get_style_defs(), code = outfile.getvalue())) class LatexEmbeddedLexer(Lexer): """ This lexer takes one lexer as argument, the lexer for the language being formatted, and the left and right delimiters for escaped text. First everything is scanned using the language lexer to obtain strings and comments. All other consecutive tokens are merged and the resulting text is scanned for escaped segments, which are given the Token.Escape type. Finally text that is not escaped is scanned again with the language lexer. """ def __init__(self, left, right, lang, **options): self.left = left self.right = right self.lang = lang Lexer.__init__(self, **options) def get_tokens_unprocessed(self, text): # find and remove all the escape tokens (replace with an empty string) # this is very similar to DelegatingLexer.get_tokens_unprocessed. buffered = '' insertions = [] insertion_buf = [] for i, t, v in self._find_safe_escape_tokens(text): if t is None: if insertion_buf: insertions.append((len(buffered), insertion_buf)) insertion_buf = [] buffered += v else: insertion_buf.append((i, t, v)) if insertion_buf: insertions.append((len(buffered), insertion_buf)) return do_insertions(insertions, self.lang.get_tokens_unprocessed(buffered)) def _find_safe_escape_tokens(self, text): """ find escape tokens that are not in strings or comments """ for i, t, v in self._filter_to( self.lang.get_tokens_unprocessed(text), lambda t: t in Token.Comment or t in Token.String ): if t is None: for i2, t2, v2 in self._find_escape_tokens(v): yield i + i2, t2, v2 else: yield i, None, v def _filter_to(self, it, pred): """ Keep only the tokens that match `pred`, merge the others together """ buf = '' idx = 0 for i, t, v in it: if pred(t): if buf: yield idx, None, buf buf = '' yield i, t, v else: if not buf: idx = i buf += v if buf: yield idx, None, buf def _find_escape_tokens(self, text): """ Find escape tokens within text, give token=None otherwise """ index = 0 while text: a, sep1, text = text.partition(self.left) if a: yield index, None, a index += len(a) if sep1: b, sep2, text = text.partition(self.right) if sep2: yield index + len(sep1), Token.Escape, b index += len(sep1) + len(b) + len(sep2) else: yield index, Token.Error, sep1 index += len(sep1) text = b PK J�Z�n�g� � groff.pynu �[��� """ pygments.formatters.groff ~~~~~~~~~~~~~~~~~~~~~~~~~ Formatter for groff output. :copyright: Copyright 2006-2021 by the Pygments team, see AUTHORS. :license: BSD, see LICENSE for details. """ import math from pip._vendor.pygments.formatter import Formatter from pip._vendor.pygments.util import get_bool_opt, get_int_opt __all__ = ['GroffFormatter'] class GroffFormatter(Formatter): """ Format tokens with groff escapes to change their color and font style. .. versionadded:: 2.11 Additional options accepted: `style` The style to use, can be a string or a Style subclass (default: ``'default'``). `monospaced` If set to true, monospace font will be used (default: ``true``). `linenos` If set to true, print the line numbers (default: ``false``). `wrap` Wrap lines to the specified number of characters. Disabled if set to 0 (default: ``0``). """ name = 'groff' aliases = ['groff','troff','roff'] filenames = [] def __init__(self, **options): Formatter.__init__(self, **options) self.monospaced = get_bool_opt(options, 'monospaced', True) self.linenos = get_bool_opt(options, 'linenos', False) self._lineno = 0 self.wrap = get_int_opt(options, 'wrap', 0) self._linelen = 0 self.styles = {} self._make_styles() def _make_styles(self): regular = '\\f[CR]' if self.monospaced else '\\f[R]' bold = '\\f[CB]' if self.monospaced else '\\f[B]' italic = '\\f[CI]' if self.monospaced else '\\f[I]' for ttype, ndef in self.style: start = end = '' if ndef['color']: start += '\\m[%s]' % ndef['color'] end = '\\m[]' + end if ndef['bold']: start += bold end = regular + end if ndef['italic']: start += italic end = regular + end if ndef['bgcolor']: start += '\\M[%s]' % ndef['bgcolor'] end = '\\M[]' + end self.styles[ttype] = start, end def _define_colors(self, outfile): colors = set() for _, ndef in self.style: if ndef['color'] is not None: colors.add(ndef['color']) for color in colors: outfile.write('.defcolor ' + color + ' rgb #' + color + '\n') def _write_lineno(self, outfile): self._lineno += 1 outfile.write("%s% 4d " % (self._lineno != 1 and '\n' or '', self._lineno)) def _wrap_line(self, line): length = len(line.rstrip('\n')) space = ' ' if self.linenos else '' newline = '' if length > self.wrap: for i in range(0, math.floor(length / self.wrap)): chunk = line[i*self.wrap:i*self.wrap+self.wrap] newline += (chunk + '\n' + space) remainder = length % self.wrap if remainder > 0: newline += line[-remainder-1:] self._linelen = remainder elif self._linelen + length > self.wrap: newline = ('\n' + space) + line self._linelen = length else: newline = line self._linelen += length return newline def _escape_chars(self, text): text = text.replace('\\', '\\[u005C]'). \ replace('.', '\\[char46]'). \ replace('\'', '\\[u0027]'). \ replace('`', '\\[u0060]'). \ replace('~', '\\[u007E]') copy = text for char in copy: if len(char) != len(char.encode()): uni = char.encode('unicode_escape') \ .decode()[1:] \ .replace('x', 'u00') \ .upper() text = text.replace(char, '\\[u' + uni[1:] + ']') return text def format_unencoded(self, tokensource, outfile): self._define_colors(outfile) outfile.write('.nf\n\\f[CR]\n') if self.linenos: self._write_lineno(outfile) for ttype, value in tokensource: start, end = self.styles[ttype] for line in value.splitlines(True): if self.wrap > 0: line = self._wrap_line(line) if start and end: text = self._escape_chars(line.rstrip('\n')) if text != '': outfile.write(''.join((start, text, end))) else: outfile.write(self._escape_chars(line.rstrip('\n'))) if line.endswith('\n'): if self.linenos: self._write_lineno(outfile) self._linelen = 0 else: outfile.write('\n') self._linelen = 0 outfile.write('\n.fi') PK J�Z?���� � rtf.pynu �[��� """ pygments.formatters.rtf ~~~~~~~~~~~~~~~~~~~~~~~ A formatter that generates RTF files. :copyright: Copyright 2006-2021 by the Pygments team, see AUTHORS. :license: BSD, see LICENSE for details. """ from pip._vendor.pygments.formatter import Formatter from pip._vendor.pygments.util import get_int_opt, surrogatepair __all__ = ['RtfFormatter'] class RtfFormatter(Formatter): """ Format tokens as RTF markup. This formatter automatically outputs full RTF documents with color information and other useful stuff. Perfect for Copy and Paste into Microsoft(R) Word(R) documents. Please note that ``encoding`` and ``outencoding`` options are ignored. The RTF format is ASCII natively, but handles unicode characters correctly thanks to escape sequences. .. versionadded:: 0.6 Additional options accepted: `style` The style to use, can be a string or a Style subclass (default: ``'default'``). `fontface` The used font family, for example ``Bitstream Vera Sans``. Defaults to some generic font which is supposed to have fixed width. `fontsize` Size of the font used. Size is specified in half points. The default is 24 half-points, giving a size 12 font. .. versionadded:: 2.0 """ name = 'RTF' aliases = ['rtf'] filenames = ['*.rtf'] def __init__(self, **options): r""" Additional options accepted: ``fontface`` Name of the font used. Could for example be ``'Courier New'`` to further specify the default which is ``'\fmodern'``. The RTF specification claims that ``\fmodern`` are "Fixed-pitch serif and sans serif fonts". Hope every RTF implementation thinks the same about modern... """ Formatter.__init__(self, **options) self.fontface = options.get('fontface') or '' self.fontsize = get_int_opt(options, 'fontsize', 0) def _escape(self, text): return text.replace('\\', '\\\\') \ .replace('{', '\\{') \ .replace('}', '\\}') def _escape_text(self, text): # empty strings, should give a small performance improvement if not text: return '' # escape text text = self._escape(text) buf = [] for c in text: cn = ord(c) if cn < (2**7): # ASCII character buf.append(str(c)) elif (2**7) <= cn < (2**16): # single unicode escape sequence buf.append('{\\u%d}' % cn) elif (2**16) <= cn: # RTF limits unicode to 16 bits. # Force surrogate pairs buf.append('{\\u%d}{\\u%d}' % surrogatepair(cn)) return ''.join(buf).replace('\n', '\\par\n') def format_unencoded(self, tokensource, outfile): # rtf 1.8 header outfile.write('{\\rtf1\\ansi\\uc0\\deff0' '{\\fonttbl{\\f0\\fmodern\\fprq1\\fcharset0%s;}}' '{\\colortbl;' % (self.fontface and ' ' + self._escape(self.fontface) or '')) # convert colors and save them in a mapping to access them later. color_mapping = {} offset = 1 for _, style in self.style: for color in style['color'], style['bgcolor'], style['border']: if color and color not in color_mapping: color_mapping[color] = offset outfile.write('\\red%d\\green%d\\blue%d;' % ( int(color[0:2], 16), int(color[2:4], 16), int(color[4:6], 16) )) offset += 1 outfile.write('}\\f0 ') if self.fontsize: outfile.write('\\fs%d' % self.fontsize) # highlight stream for ttype, value in tokensource: while not self.style.styles_token(ttype) and ttype.parent: ttype = ttype.parent style = self.style.style_for_token(ttype) buf = [] if style['bgcolor']: buf.append('\\cb%d' % color_mapping[style['bgcolor']]) if style['color']: buf.append('\\cf%d' % color_mapping[style['color']]) if style['bold']: buf.append('\\b') if style['italic']: buf.append('\\i') if style['underline']: buf.append('\\ul') if style['border']: buf.append('\\chbrdr\\chcfpat%d' % color_mapping[style['border']]) start = ''.join(buf) if start: outfile.write('{%s ' % start) outfile.write(self._escape_text(value)) if start: outfile.write('}') outfile.write('}') PK J�Z ٫� � html.pynu �[��� """ pygments.formatters.html ~~~~~~~~~~~~~~~~~~~~~~~~ Formatter for HTML output. :copyright: Copyright 2006-2021 by the Pygments team, see AUTHORS. :license: BSD, see LICENSE for details. """ import functools import os import sys import os.path from io import StringIO from pip._vendor.pygments.formatter import Formatter from pip._vendor.pygments.token import Token, Text, STANDARD_TYPES from pip._vendor.pygments.util import get_bool_opt, get_int_opt, get_list_opt try: import ctags except ImportError: ctags = None __all__ = ['HtmlFormatter'] _escape_html_table = { ord('&'): '&', ord('<'): '<', ord('>'): '>', ord('"'): '"', ord("'"): ''', } def escape_html(text, table=_escape_html_table): """Escape &, <, > as well as single and double quotes for HTML.""" return text.translate(table) def webify(color): if color.startswith('calc') or color.startswith('var'): return color else: return '#' + color def _get_ttype_class(ttype): fname = STANDARD_TYPES.get(ttype) if fname: return fname aname = '' while fname is None: aname = '-' + ttype[-1] + aname ttype = ttype.parent fname = STANDARD_TYPES.get(ttype) return fname + aname CSSFILE_TEMPLATE = '''\ /* generated by Pygments <https://pygments.org/> Copyright 2006-2021 by the Pygments team. Licensed under the BSD license, see LICENSE for details. */ %(styledefs)s ''' DOC_HEADER = '''\ <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd"> <!-- generated by Pygments <https://pygments.org/> Copyright 2006-2021 by the Pygments team. Licensed under the BSD license, see LICENSE for details. --> <html> <head> <title>%(title)s</title> <meta http-equiv="content-type" content="text/html; charset=%(encoding)s"> <style type="text/css"> ''' + CSSFILE_TEMPLATE + ''' </style> </head> <body> <h2>%(title)s</h2> ''' DOC_HEADER_EXTERNALCSS = '''\ <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd"> <html> <head> <title>%(title)s</title> <meta http-equiv="content-type" content="text/html; charset=%(encoding)s"> <link rel="stylesheet" href="%(cssfile)s" type="text/css"> </head> <body> <h2>%(title)s</h2> ''' DOC_FOOTER = '''\ </body> </html> ''' class HtmlFormatter(Formatter): r""" Format tokens as HTML 4 ``<span>`` tags within a ``<pre>`` tag, wrapped in a ``<div>`` tag. The ``<div>``'s CSS class can be set by the `cssclass` option. If the `linenos` option is set to ``"table"``, the ``<pre>`` is additionally wrapped inside a ``<table>`` which has one row and two cells: one containing the line numbers and one containing the code. Example: .. sourcecode:: html <div class="highlight" > <table><tr> <td class="linenos" title="click to toggle" onclick="with (this.firstChild.style) { display = (display == '') ? 'none' : '' }"> <pre>1 2</pre> </td> <td class="code"> <pre><span class="Ke">def </span><span class="NaFu">foo</span>(bar): <span class="Ke">pass</span> </pre> </td> </tr></table></div> (whitespace added to improve clarity). Wrapping can be disabled using the `nowrap` option. A list of lines can be specified using the `hl_lines` option to make these lines highlighted (as of Pygments 0.11). With the `full` option, a complete HTML 4 document is output, including the style definitions inside a ``<style>`` tag, or in a separate file if the `cssfile` option is given. When `tagsfile` is set to the path of a ctags index file, it is used to generate hyperlinks from names to their definition. You must enable `lineanchors` and run ctags with the `-n` option for this to work. The `python-ctags` module from PyPI must be installed to use this feature; otherwise a `RuntimeError` will be raised. The `get_style_defs(arg='')` method of a `HtmlFormatter` returns a string containing CSS rules for the CSS classes used by the formatter. The argument `arg` can be used to specify additional CSS selectors that are prepended to the classes. A call `fmter.get_style_defs('td .code')` would result in the following CSS classes: .. sourcecode:: css td .code .kw { font-weight: bold; color: #00FF00 } td .code .cm { color: #999999 } ... If you have Pygments 0.6 or higher, you can also pass a list or tuple to the `get_style_defs()` method to request multiple prefixes for the tokens: .. sourcecode:: python formatter.get_style_defs(['div.syntax pre', 'pre.syntax']) The output would then look like this: .. sourcecode:: css div.syntax pre .kw, pre.syntax .kw { font-weight: bold; color: #00FF00 } div.syntax pre .cm, pre.syntax .cm { color: #999999 } ... Additional options accepted: `nowrap` If set to ``True``, don't wrap the tokens at all, not even inside a ``<pre>`` tag. This disables most other options (default: ``False``). `full` Tells the formatter to output a "full" document, i.e. a complete self-contained document (default: ``False``). `title` If `full` is true, the title that should be used to caption the document (default: ``''``). `style` The style to use, can be a string or a Style subclass (default: ``'default'``). This option has no effect if the `cssfile` and `noclobber_cssfile` option are given and the file specified in `cssfile` exists. `noclasses` If set to true, token ``<span>`` tags (as well as line number elements) will not use CSS classes, but inline styles. This is not recommended for larger pieces of code since it increases output size by quite a bit (default: ``False``). `classprefix` Since the token types use relatively short class names, they may clash with some of your own class names. In this case you can use the `classprefix` option to give a string to prepend to all Pygments-generated CSS class names for token types. Note that this option also affects the output of `get_style_defs()`. `cssclass` CSS class for the wrapping ``<div>`` tag (default: ``'highlight'``). If you set this option, the default selector for `get_style_defs()` will be this class. .. versionadded:: 0.9 If you select the ``'table'`` line numbers, the wrapping table will have a CSS class of this string plus ``'table'``, the default is accordingly ``'highlighttable'``. `cssstyles` Inline CSS styles for the wrapping ``<div>`` tag (default: ``''``). `prestyles` Inline CSS styles for the ``<pre>`` tag (default: ``''``). .. versionadded:: 0.11 `cssfile` If the `full` option is true and this option is given, it must be the name of an external file. If the filename does not include an absolute path, the file's path will be assumed to be relative to the main output file's path, if the latter can be found. The stylesheet is then written to this file instead of the HTML file. .. versionadded:: 0.6 `noclobber_cssfile` If `cssfile` is given and the specified file exists, the css file will not be overwritten. This allows the use of the `full` option in combination with a user specified css file. Default is ``False``. .. versionadded:: 1.1 `linenos` If set to ``'table'``, output line numbers as a table with two cells, one containing the line numbers, the other the whole code. This is copy-and-paste-friendly, but may cause alignment problems with some browsers or fonts. If set to ``'inline'``, the line numbers will be integrated in the ``<pre>`` tag that contains the code (that setting is *new in Pygments 0.8*). For compatibility with Pygments 0.7 and earlier, every true value except ``'inline'`` means the same as ``'table'`` (in particular, that means also ``True``). The default value is ``False``, which means no line numbers at all. **Note:** with the default ("table") line number mechanism, the line numbers and code can have different line heights in Internet Explorer unless you give the enclosing ``<pre>`` tags an explicit ``line-height`` CSS property (you get the default line spacing with ``line-height: 125%``). `hl_lines` Specify a list of lines to be highlighted. The line numbers are always relative to the input (i.e. the first line is line 1) and are independent of `linenostart`. .. versionadded:: 0.11 `linenostart` The line number for the first line (default: ``1``). `linenostep` If set to a number n > 1, only every nth line number is printed. `linenospecial` If set to a number n > 0, every nth line number is given the CSS class ``"special"`` (default: ``0``). `nobackground` If set to ``True``, the formatter won't output the background color for the wrapping element (this automatically defaults to ``False`` when there is no wrapping element [eg: no argument for the `get_syntax_defs` method given]) (default: ``False``). .. versionadded:: 0.6 `lineseparator` This string is output between lines of code. It defaults to ``"\n"``, which is enough to break a line inside ``<pre>`` tags, but you can e.g. set it to ``"<br>"`` to get HTML line breaks. .. versionadded:: 0.7 `lineanchors` If set to a nonempty string, e.g. ``foo``, the formatter will wrap each output line in an anchor tag with an ``id`` (and `name`) of ``foo-linenumber``. This allows easy linking to certain lines. .. versionadded:: 0.9 `linespans` If set to a nonempty string, e.g. ``foo``, the formatter will wrap each output line in a span tag with an ``id`` of ``foo-linenumber``. This allows easy access to lines via javascript. .. versionadded:: 1.6 `anchorlinenos` If set to `True`, will wrap line numbers in <a> tags. Used in combination with `linenos` and `lineanchors`. `tagsfile` If set to the path of a ctags file, wrap names in anchor tags that link to their definitions. `lineanchors` should be used, and the tags file should specify line numbers (see the `-n` option to ctags). .. versionadded:: 1.6 `tagurlformat` A string formatting pattern used to generate links to ctags definitions. Available variables are `%(path)s`, `%(fname)s` and `%(fext)s`. Defaults to an empty string, resulting in just `#prefix-number` links. .. versionadded:: 1.6 `filename` A string used to generate a filename when rendering ``<pre>`` blocks, for example if displaying source code. If `linenos` is set to ``'table'`` then the filename will be rendered in an initial row containing a single `<th>` which spans both columns. .. versionadded:: 2.1 `wrapcode` Wrap the code inside ``<pre>`` blocks using ``<code>``, as recommended by the HTML5 specification. .. versionadded:: 2.4 `debug_token_types` Add ``title`` attributes to all token ``<span>`` tags that show the name of the token. .. versionadded:: 2.10 **Subclassing the HTML formatter** .. versionadded:: 0.7 The HTML formatter is now built in a way that allows easy subclassing, thus customizing the output HTML code. The `format()` method calls `self._format_lines()` which returns a generator that yields tuples of ``(1, line)``, where the ``1`` indicates that the ``line`` is a line of the formatted source code. If the `nowrap` option is set, the generator is the iterated over and the resulting HTML is output. Otherwise, `format()` calls `self.wrap()`, which wraps the generator with other generators. These may add some HTML code to the one generated by `_format_lines()`, either by modifying the lines generated by the latter, then yielding them again with ``(1, line)``, and/or by yielding other HTML code before or after the lines, with ``(0, html)``. The distinction between source lines and other code makes it possible to wrap the generator multiple times. The default `wrap()` implementation adds a ``<div>`` and a ``<pre>`` tag. A custom `HtmlFormatter` subclass could look like this: .. sourcecode:: python class CodeHtmlFormatter(HtmlFormatter): def wrap(self, source, outfile): return self._wrap_code(source) def _wrap_code(self, source): yield 0, '<code>' for i, t in source: if i == 1: # it's a line of formatted code t += '<br>' yield i, t yield 0, '</code>' This results in wrapping the formatted lines with a ``<code>`` tag, where the source lines are broken using ``<br>`` tags. After calling `wrap()`, the `format()` method also adds the "line numbers" and/or "full document" wrappers if the respective options are set. Then, all HTML yielded by the wrapped generator is output. """ name = 'HTML' aliases = ['html'] filenames = ['*.html', '*.htm'] def __init__(self, **options): Formatter.__init__(self, **options) self.title = self._decodeifneeded(self.title) self.nowrap = get_bool_opt(options, 'nowrap', False) self.noclasses = get_bool_opt(options, 'noclasses', False) self.classprefix = options.get('classprefix', '') self.cssclass = self._decodeifneeded(options.get('cssclass', 'highlight')) self.cssstyles = self._decodeifneeded(options.get('cssstyles', '')) self.prestyles = self._decodeifneeded(options.get('prestyles', '')) self.cssfile = self._decodeifneeded(options.get('cssfile', '')) self.noclobber_cssfile = get_bool_opt(options, 'noclobber_cssfile', False) self.tagsfile = self._decodeifneeded(options.get('tagsfile', '')) self.tagurlformat = self._decodeifneeded(options.get('tagurlformat', '')) self.filename = self._decodeifneeded(options.get('filename', '')) self.wrapcode = get_bool_opt(options, 'wrapcode', False) self.span_element_openers = {} self.debug_token_types = get_bool_opt(options, 'debug_token_types', False) if self.tagsfile: if not ctags: raise RuntimeError('The "ctags" package must to be installed ' 'to be able to use the "tagsfile" feature.') self._ctags = ctags.CTags(self.tagsfile) linenos = options.get('linenos', False) if linenos == 'inline': self.linenos = 2 elif linenos: # compatibility with <= 0.7 self.linenos = 1 else: self.linenos = 0 self.linenostart = abs(get_int_opt(options, 'linenostart', 1)) self.linenostep = abs(get_int_opt(options, 'linenostep', 1)) self.linenospecial = abs(get_int_opt(options, 'linenospecial', 0)) self.nobackground = get_bool_opt(options, 'nobackground', False) self.lineseparator = options.get('lineseparator', '\n') self.lineanchors = options.get('lineanchors', '') self.linespans = options.get('linespans', '') self.anchorlinenos = get_bool_opt(options, 'anchorlinenos', False) self.hl_lines = set() for lineno in get_list_opt(options, 'hl_lines', []): try: self.hl_lines.add(int(lineno)) except ValueError: pass self._create_stylesheet() def _get_css_class(self, ttype): """Return the css class of this token type prefixed with the classprefix option.""" ttypeclass = _get_ttype_class(ttype) if ttypeclass: return self.classprefix + ttypeclass return '' def _get_css_classes(self, ttype): """Return the CSS classes of this token type prefixed with the classprefix option.""" cls = self._get_css_class(ttype) while ttype not in STANDARD_TYPES: ttype = ttype.parent cls = self._get_css_class(ttype) + ' ' + cls return cls or '' def _get_css_inline_styles(self, ttype): """Return the inline CSS styles for this token type.""" cclass = self.ttype2class.get(ttype) while cclass is None: ttype = ttype.parent cclass = self.ttype2class.get(ttype) return cclass or '' def _create_stylesheet(self): t2c = self.ttype2class = {Token: ''} c2s = self.class2style = {} for ttype, ndef in self.style: name = self._get_css_class(ttype) style = '' if ndef['color']: style += 'color: %s; ' % webify(ndef['color']) if ndef['bold']: style += 'font-weight: bold; ' if ndef['italic']: style += 'font-style: italic; ' if ndef['underline']: style += 'text-decoration: underline; ' if ndef['bgcolor']: style += 'background-color: %s; ' % webify(ndef['bgcolor']) if ndef['border']: style += 'border: 1px solid %s; ' % webify(ndef['border']) if style: t2c[ttype] = name # save len(ttype) to enable ordering the styles by # hierarchy (necessary for CSS cascading rules!) c2s[name] = (style[:-2], ttype, len(ttype)) def get_style_defs(self, arg=None): """ Return CSS style definitions for the classes produced by the current highlighting style. ``arg`` can be a string or list of selectors to insert before the token type classes. """ style_lines = [] style_lines.extend(self.get_linenos_style_defs()) style_lines.extend(self.get_background_style_defs(arg)) style_lines.extend(self.get_token_style_defs(arg)) return '\n'.join(style_lines) def get_token_style_defs(self, arg=None): prefix = self.get_css_prefix(arg) styles = [ (level, ttype, cls, style) for cls, (style, ttype, level) in self.class2style.items() if cls and style ] styles.sort() lines = [ '%s { %s } /* %s */' % (prefix(cls), style, repr(ttype)[6:]) for (level, ttype, cls, style) in styles ] return lines def get_background_style_defs(self, arg=None): prefix = self.get_css_prefix(arg) bg_color = self.style.background_color hl_color = self.style.highlight_color lines = [] if arg and not self.nobackground and bg_color is not None: text_style = '' if Text in self.ttype2class: text_style = ' ' + self.class2style[self.ttype2class[Text]][0] lines.insert( 0, '%s{ background: %s;%s }' % ( prefix(''), bg_color, text_style ) ) if hl_color is not None: lines.insert( 0, '%s { background-color: %s }' % (prefix('hll'), hl_color) ) return lines def get_linenos_style_defs(self): lines = [ 'pre { %s }' % self._pre_style, 'td.linenos .normal { %s }' % self._linenos_style, 'span.linenos { %s }' % self._linenos_style, 'td.linenos .special { %s }' % self._linenos_special_style, 'span.linenos.special { %s }' % self._linenos_special_style, ] return lines def get_css_prefix(self, arg): if arg is None: arg = ('cssclass' in self.options and '.'+self.cssclass or '') if isinstance(arg, str): args = [arg] else: args = list(arg) def prefix(cls): if cls: cls = '.' + cls tmp = [] for arg in args: tmp.append((arg and arg + ' ' or '') + cls) return ', '.join(tmp) return prefix @property def _pre_style(self): return 'line-height: 125%;' @property def _linenos_style(self): return 'color: %s; background-color: %s; padding-left: 5px; padding-right: 5px;' % ( self.style.line_number_color, self.style.line_number_background_color ) @property def _linenos_special_style(self): return 'color: %s; background-color: %s; padding-left: 5px; padding-right: 5px;' % ( self.style.line_number_special_color, self.style.line_number_special_background_color ) def _decodeifneeded(self, value): if isinstance(value, bytes): if self.encoding: return value.decode(self.encoding) return value.decode() return value def _wrap_full(self, inner, outfile): if self.cssfile: if os.path.isabs(self.cssfile): # it's an absolute filename cssfilename = self.cssfile else: try: filename = outfile.name if not filename or filename[0] == '<': # pseudo files, e.g. name == '<fdopen>' raise AttributeError cssfilename = os.path.join(os.path.dirname(filename), self.cssfile) except AttributeError: print('Note: Cannot determine output file name, ' 'using current directory as base for the CSS file name', file=sys.stderr) cssfilename = self.cssfile # write CSS file only if noclobber_cssfile isn't given as an option. try: if not os.path.exists(cssfilename) or not self.noclobber_cssfile: with open(cssfilename, "w") as cf: cf.write(CSSFILE_TEMPLATE % {'styledefs': self.get_style_defs('body')}) except OSError as err: err.strerror = 'Error writing CSS file: ' + err.strerror raise yield 0, (DOC_HEADER_EXTERNALCSS % dict(title=self.title, cssfile=self.cssfile, encoding=self.encoding)) else: yield 0, (DOC_HEADER % dict(title=self.title, styledefs=self.get_style_defs('body'), encoding=self.encoding)) yield from inner yield 0, DOC_FOOTER def _wrap_tablelinenos(self, inner): dummyoutfile = StringIO() lncount = 0 for t, line in inner: if t: lncount += 1 dummyoutfile.write(line) fl = self.linenostart mw = len(str(lncount + fl - 1)) sp = self.linenospecial st = self.linenostep la = self.lineanchors aln = self.anchorlinenos nocls = self.noclasses lines = [] for i in range(fl, fl+lncount): print_line = i % st == 0 special_line = sp and i % sp == 0 if print_line: line = '%*d' % (mw, i) if aln: line = '<a href="#%s-%d">%s</a>' % (la, i, line) else: line = ' ' * mw if nocls: if special_line: style = ' style="%s"' % self._linenos_special_style else: style = ' style="%s"' % self._linenos_style else: if special_line: style = ' class="special"' else: style = ' class="normal"' if style: line = '<span%s>%s</span>' % (style, line) lines.append(line) ls = '\n'.join(lines) # If a filename was specified, we can't put it into the code table as it # would misalign the line numbers. Hence we emit a separate row for it. filename_tr = "" if self.filename: filename_tr = ( '<tr><th colspan="2" class="filename"><div class="highlight">' '<span class="filename">' + self.filename + '</span></div>' '</th></tr>') # in case you wonder about the seemingly redundant <div> here: since the # content in the other cell also is wrapped in a div, some browsers in # some configurations seem to mess up the formatting... yield 0, ( '<table class="%stable">' % self.cssclass + filename_tr + '<tr><td class="linenos"><div class="linenodiv"><pre>' + ls + '</pre></div></td><td class="code">' ) yield 0, dummyoutfile.getvalue() yield 0, '</td></tr></table>' def _wrap_inlinelinenos(self, inner): # need a list of lines since we need the width of a single number :( inner_lines = list(inner) sp = self.linenospecial st = self.linenostep num = self.linenostart mw = len(str(len(inner_lines) + num - 1)) la = self.lineanchors aln = self.anchorlinenos nocls = self.noclasses for _, inner_line in inner_lines: print_line = num % st == 0 special_line = sp and num % sp == 0 if print_line: line = '%*d' % (mw, num) else: line = ' ' * mw if nocls: if special_line: style = ' style="%s"' % self._linenos_special_style else: style = ' style="%s"' % self._linenos_style else: if special_line: style = ' class="linenos special"' else: style = ' class="linenos"' if style: linenos = '<span%s>%s</span>' % (style, line) else: linenos = line if aln: yield 1, ('<a href="#%s-%d">%s</a>' % (la, num, linenos) + inner_line) else: yield 1, linenos + inner_line num += 1 def _wrap_lineanchors(self, inner): s = self.lineanchors # subtract 1 since we have to increment i *before* yielding i = self.linenostart - 1 for t, line in inner: if t: i += 1 href = "" if self.linenos else ' href="#%s-%d"' % (s, i) yield 1, '<a id="%s-%d" name="%s-%d"%s></a>' % (s, i, s, i, href) + line else: yield 0, line def _wrap_linespans(self, inner): s = self.linespans i = self.linenostart - 1 for t, line in inner: if t: i += 1 yield 1, '<span id="%s-%d">%s</span>' % (s, i, line) else: yield 0, line def _wrap_div(self, inner): style = [] if (self.noclasses and not self.nobackground and self.style.background_color is not None): style.append('background: %s' % (self.style.background_color,)) if self.cssstyles: style.append(self.cssstyles) style = '; '.join(style) yield 0, ('<div' + (self.cssclass and ' class="%s"' % self.cssclass) + (style and (' style="%s"' % style)) + '>') yield from inner yield 0, '</div>\n' def _wrap_pre(self, inner): style = [] if self.prestyles: style.append(self.prestyles) if self.noclasses: style.append(self._pre_style) style = '; '.join(style) if self.filename and self.linenos != 1: yield 0, ('<span class="filename">' + self.filename + '</span>') # the empty span here is to keep leading empty lines from being # ignored by HTML parsers yield 0, ('<pre' + (style and ' style="%s"' % style) + '><span></span>') yield from inner yield 0, '</pre>' def _wrap_code(self, inner): yield 0, '<code>' yield from inner yield 0, '</code>' @functools.lru_cache(maxsize=100) def _translate_parts(self, value): """HTML-escape a value and split it by newlines.""" return value.translate(_escape_html_table).split('\n') def _format_lines(self, tokensource): """ Just format the tokens, without any wrapping tags. Yield individual lines. """ nocls = self.noclasses lsep = self.lineseparator tagsfile = self.tagsfile lspan = '' line = [] for ttype, value in tokensource: try: cspan = self.span_element_openers[ttype] except KeyError: title = ' title="%s"' % '.'.join(ttype) if self.debug_token_types else '' if nocls: css_style = self._get_css_inline_styles(ttype) if css_style: css_style = self.class2style[css_style][0] cspan = '<span style="%s"%s>' % (css_style, title) else: cspan = '' else: css_class = self._get_css_classes(ttype) if css_class: cspan = '<span class="%s"%s>' % (css_class, title) else: cspan = '' self.span_element_openers[ttype] = cspan parts = self._translate_parts(value) if tagsfile and ttype in Token.Name: filename, linenumber = self._lookup_ctag(value) if linenumber: base, filename = os.path.split(filename) if base: base += '/' filename, extension = os.path.splitext(filename) url = self.tagurlformat % {'path': base, 'fname': filename, 'fext': extension} parts[0] = "<a href=\"%s#%s-%d\">%s" % \ (url, self.lineanchors, linenumber, parts[0]) parts[-1] = parts[-1] + "</a>" # for all but the last line for part in parts[:-1]: if line: if lspan != cspan: line.extend(((lspan and '</span>'), cspan, part, (cspan and '</span>'), lsep)) else: # both are the same line.extend((part, (lspan and '</span>'), lsep)) yield 1, ''.join(line) line = [] elif part: yield 1, ''.join((cspan, part, (cspan and '</span>'), lsep)) else: yield 1, lsep # for the last line if line and parts[-1]: if lspan != cspan: line.extend(((lspan and '</span>'), cspan, parts[-1])) lspan = cspan else: line.append(parts[-1]) elif parts[-1]: line = [cspan, parts[-1]] lspan = cspan # else we neither have to open a new span nor set lspan if line: line.extend(((lspan and '</span>'), lsep)) yield 1, ''.join(line) def _lookup_ctag(self, token): entry = ctags.TagEntry() if self._ctags.find(entry, token.encode(), 0): return entry['file'], entry['lineNumber'] else: return None, None def _highlight_lines(self, tokensource): """ Highlighted the lines specified in the `hl_lines` option by post-processing the token stream coming from `_format_lines`. """ hls = self.hl_lines for i, (t, value) in enumerate(tokensource): if t != 1: yield t, value if i + 1 in hls: # i + 1 because Python indexes start at 0 if self.noclasses: style = '' if self.style.highlight_color is not None: style = (' style="background-color: %s"' % (self.style.highlight_color,)) yield 1, '<span%s>%s</span>' % (style, value) else: yield 1, '<span class="hll">%s</span>' % value else: yield 1, value def wrap(self, source, outfile): """ Wrap the ``source``, which is a generator yielding individual lines, in custom generators. See docstring for `format`. Can be overridden. """ if self.wrapcode: return self._wrap_div(self._wrap_pre(self._wrap_code(source))) else: return self._wrap_div(self._wrap_pre(source)) def format_unencoded(self, tokensource, outfile): """ The formatting process uses several nested generators; which of them are used is determined by the user's options. Each generator should take at least one argument, ``inner``, and wrap the pieces of text generated by this. Always yield 2-tuples: (code, text). If "code" is 1, the text is part of the original tokensource being highlighted, if it's 0, the text is some piece of wrapping. This makes it possible to use several different wrappers that process the original source linewise, e.g. line number generators. """ source = self._format_lines(tokensource) # As a special case, we wrap line numbers before line highlighting # so the line numbers get wrapped in the highlighting tag. if not self.nowrap and self.linenos == 2: source = self._wrap_inlinelinenos(source) if self.hl_lines: source = self._highlight_lines(source) if not self.nowrap: if self.lineanchors: source = self._wrap_lineanchors(source) if self.linespans: source = self._wrap_linespans(source) source = self.wrap(source, outfile) if self.linenos == 1: source = self._wrap_tablelinenos(source) if self.full: source = self._wrap_full(source, outfile) for t, piece in source: outfile.write(piece) PK J�Zo�� � __init__.pynu �[��� """ pygments.formatters ~~~~~~~~~~~~~~~~~~~ Pygments formatters. :copyright: Copyright 2006-2021 by the Pygments team, see AUTHORS. :license: BSD, see LICENSE for details. """ import re import sys import types import fnmatch from os.path import basename from pip._vendor.pygments.formatters._mapping import FORMATTERS from pip._vendor.pygments.plugin import find_plugin_formatters from pip._vendor.pygments.util import ClassNotFound __all__ = ['get_formatter_by_name', 'get_formatter_for_filename', 'get_all_formatters', 'load_formatter_from_file'] + list(FORMATTERS) _formatter_cache = {} # classes by name _pattern_cache = {} def _fn_matches(fn, glob): """Return whether the supplied file name fn matches pattern filename.""" if glob not in _pattern_cache: pattern = _pattern_cache[glob] = re.compile(fnmatch.translate(glob)) return pattern.match(fn) return _pattern_cache[glob].match(fn) def _load_formatters(module_name): """Load a formatter (and all others in the module too).""" mod = __import__(module_name, None, None, ['__all__']) for formatter_name in mod.__all__: cls = getattr(mod, formatter_name) _formatter_cache[cls.name] = cls def get_all_formatters(): """Return a generator for all formatter classes.""" # NB: this returns formatter classes, not info like get_all_lexers(). for info in FORMATTERS.values(): if info[1] not in _formatter_cache: _load_formatters(info[0]) yield _formatter_cache[info[1]] for _, formatter in find_plugin_formatters(): yield formatter def find_formatter_class(alias): """Lookup a formatter by alias. Returns None if not found. """ for module_name, name, aliases, _, _ in FORMATTERS.values(): if alias in aliases: if name not in _formatter_cache: _load_formatters(module_name) return _formatter_cache[name] for _, cls in find_plugin_formatters(): if alias in cls.aliases: return cls def get_formatter_by_name(_alias, **options): """Lookup and instantiate a formatter by alias. Raises ClassNotFound if not found. """ cls = find_formatter_class(_alias) if cls is None: raise ClassNotFound("no formatter found for name %r" % _alias) return cls(**options) def load_formatter_from_file(filename, formattername="CustomFormatter", **options): """Load a formatter from a file. This method expects a file located relative to the current working directory, which contains a class named CustomFormatter. By default, it expects the Formatter to be named CustomFormatter; you can specify your own class name as the second argument to this function. Users should be very careful with the input, because this method is equivalent to running eval on the input file. Raises ClassNotFound if there are any problems importing the Formatter. .. versionadded:: 2.2 """ try: # This empty dict will contain the namespace for the exec'd file custom_namespace = {} with open(filename, 'rb') as f: exec(f.read(), custom_namespace) # Retrieve the class `formattername` from that namespace if formattername not in custom_namespace: raise ClassNotFound('no valid %s class found in %s' % (formattername, filename)) formatter_class = custom_namespace[formattername] # And finally instantiate it with the options return formatter_class(**options) except OSError as err: raise ClassNotFound('cannot read %s: %s' % (filename, err)) except ClassNotFound: raise except Exception as err: raise ClassNotFound('error when loading custom formatter: %s' % err) def get_formatter_for_filename(fn, **options): """Lookup and instantiate a formatter by filename pattern. Raises ClassNotFound if not found. """ fn = basename(fn) for modname, name, _, filenames, _ in FORMATTERS.values(): for filename in filenames: if _fn_matches(fn, filename): if name not in _formatter_cache: _load_formatters(modname) return _formatter_cache[name](**options) for cls in find_plugin_formatters(): for filename in cls.filenames: if _fn_matches(fn, filename): return cls(**options) raise ClassNotFound("no formatter found for file name %r" % fn) class _automodule(types.ModuleType): """Automatically import formatters.""" def __getattr__(self, name): info = FORMATTERS.get(name) if info: _load_formatters(info[0]) cls = _formatter_cache[info[1]] setattr(self, name, cls) return cls raise AttributeError(name) oldmod = sys.modules[__name__] newmod = _automodule(__name__) newmod.__dict__.update(oldmod.__dict__) sys.modules[__name__] = newmod del newmod.newmod, newmod.oldmod, newmod.sys, newmod.types PK J�Z['*�� � other.pynu �[��� PK J�ZH��{ { $ __pycache__/_mapping.cpython-310.pycnu �[��� PK J�Z�pb� � ! �) __pycache__/other.cpython-310.pycnu �[��� PK J�ZiF� $ �< __pycache__/__init__.cpython-310.pycnu �[��� PK J�Z�{�4 �4 ! 5O __pycache__/latex.cpython-310.pycnu �[��� PK J�ZDRSB� � ! � __pycache__/groff.cpython-310.pycnu �[��� PK J�Z4��iq iq K� __pycache__/html.cpython-310.pycnu �[��� PK J�Z ��;� � __pycache__/svg.cpython-310.pycnu �[��� PK J�Z)n ' � __pycache__/pangomarkup.cpython-310.pycnu �[��� PK J�ZF>��5D 5D V( __pycache__/img.cpython-310.pycnu �[��� PK J�Z�<X`� � " �l __pycache__/bbcode.cpython-310.pycnu �[��� PK J�Z�^�� y __pycache__/rtf.cpython-310.pycnu �[��� PK J�Z�Q�{ { $ f� __pycache__/terminal.cpython-310.pycnu �[��� PK J�ZUF��# �# ' 5� __pycache__/terminal256.cpython-310.pycnu �[��� PK J�ZX%� � �� __pycache__/irc.cpython-310.pycnu �[��� PK J�ZWT��� � �� irc.pynu �[��� PK J�Z���}� � �� svg.pynu �[��� PK J�Z��1J�- �- � terminal256.pynu �[��� PK J�Zy�u/;U ;U �1 img.pynu �[��� PK J�Z�̠^� � :� bbcode.pynu �[��� PK J�ZV(��t t e� _mapping.pynu �[��� PK J�Z���B B � terminal.pynu �[��� PK J�Z��܊� � �� pangomarkup.pynu �[��� PK J�Z� �(�I �I s� latex.pynu �[��� PK J�Z�n�g� � � groff.pynu �[��� PK J�Z?���� � b' rtf.pynu �[��� PK J�Z ٫� � .; html.pynu �[��� PK J�Zo�� � g� __init__.pynu �[��� PK X ��
| ver. 1.4 |
Github
|
.
| PHP 8.2.28 | Generation time: 0.02 |
proxy
|
phpinfo
|
Settings