shell bypass 403
UnknownSec Shell
:
/
lib
/
python3
/
dist-packages
/
markdown
/
__pycache__
/ [
drwxr-xr-x
]
upload
mass deface
mass delete
console
info server
name :
core.cpython-312.pyc
� ���eWS � �& � d dl mZ d dlZd dlZd dlZd dlZd dlmZmZm Z m Z m Z m Z m Z ddlmZ ddlmZ ddlmZ ddlmZ dd lmZ dd lmZ dd lmZ dd l m Z m Z dd lm Z erd dl m!Z! g d�Z" ejF d� Z$ G d� d� Z% dd�Z&dd�Z'y)� )� annotationsN)� TYPE_CHECKING�Any�BinaryIO�Callable�ClassVar�Mapping�Sequence� )�util)�build_preprocessors)�build_block_parser)�build_treeprocessors)�build_inlinepatterns)�build_postprocessors)� Extension)�to_html_string�to_xhtml_string)�BLOCK_LEVEL_ELEMENTS)�Element)�Markdown�markdown�markdownFromFile�MARKDOWNc � � e Zd ZU dZdZeed�Zded< d� Z dd�Z dd�Z dd �Z dd �Z dd �Zdd �Zdd �Zdd�Z d dd�Zy)r a A parser which converts Markdown to HTML. Attributes: Markdown.tab_length (int): The number of spaces which correspond to a single tab. Default: `4`. Markdown.ESCAPED_CHARS (list[str]): List of characters which get the backslash escape treatment. Markdown.block_level_elements (list[str]): List of HTML tags which get treated as block-level elements. See [`markdown.util.BLOCK_LEVEL_ELEMENTS`][] for the full list of elements. Markdown.registeredExtensions (list[Extension]): List of extensions which have called [`registerExtension`][markdown.Markdown.registerExtension] during setup. Markdown.doc_tag (str): Element used to wrap document. Default: `div`. Markdown.stripTopLevelTags (bool): Indicates whether the `doc_tag` should be removed. Default: 'True'. Markdown.references (dict[str, tuple[str, str]]): A mapping of link references found in a parsed document where the key is the reference name and the value is a tuple of the URL and title. Markdown.htmlStash (util.HtmlStash): The instance of the `HtmlStash` used by an instance of this class. Markdown.output_formats (dict[str, Callable[xml.etree.ElementTree.Element]]): A mapping of known output formats by name and their respective serializers. Each serializer must be a callable which accepts an [`Element`][xml.etree.ElementTree.Element] and returns a `str`. Markdown.output_format (str): The output format set by [`set_output_format`][markdown.Markdown.set_output_format]. Markdown.serializer (Callable[xml.etree.ElementTree.Element]): The serializer set by [`set_output_format`][markdown.Markdown.set_output_format]. Markdown.preprocessors (util.Registry): A collection of [`preprocessors`][markdown.preprocessors]. Markdown.parser (blockparser.BlockParser): A collection of [`blockprocessors`][markdown.blockprocessors]. Markdown.inlinePatterns (util.Registry): A collection of [`inlinepatterns`][markdown.inlinepatterns]. Markdown.treeprocessors (util.Registry): A collection of [`treeprocessors`][markdown.treeprocessors]. Markdown.postprocessors (util.Registry): A collection of [`postprocessors`][markdown.postprocessors]. �div)�html�xhtmlz-ClassVar[dict[str, Callable[[Element], str]]]�output_formatsc �� � |j dd� | _ g d�| _ t j � | _ g | _ d| _ d| _ | j � i | _ t j � | _ | j |j dg � |j di � �� | j |j d d � � | j! � y ) a� Creates a new Markdown instance. Keyword Arguments: extensions (list[Extension | str]): A list of extensions. If an item is an instance of a subclass of [`markdown.extensions.Extension`][], the instance will be used as-is. If an item is of type `str`, it is passed to [`build_extension`][markdown.Markdown.build_extension] with its corresponding `extension_configs` and the returned instance of [`markdown.extensions.Extension`][] is used. extension_configs (dict[str, dict[str, Any]]): Configuration settings for extensions. output_format (str): Format of output. Supported formats are: * `xhtml`: Outputs XHTML style tags. Default. * `html`: Outputs HTML style tags. tab_length (int): Length of tabs in the source. Default: `4` � tab_length� )�\�`�*�_�{�}�[�]�(�)�>�#�+�-�.�!� T� extensions�extension_configs)r4 �configs� output_formatr N)�getr! � ESCAPED_CHARSr �copy�block_level_elements�registeredExtensions�docType�stripTopLevelTags� build_parser� referencesr � HtmlStash� htmlStash�registerExtensions�set_output_format�reset)�self�kwargss �//usr/lib/python3/dist-packages/markdown/core.py�__init__zMarkdown.__init__X s� � �* &�z�z�,�� :���) ��� M�/C�/H�/H�/J��!�57��!��� �'+�� � ����68���)-� � �)9��� � � �6�:�:�l�B�+G�(.� � �3F��(K� � M� � � �v�z�z�/�7� C�D� � � � � c � � t | � | _ t | � | _ t | � | _ t | � | _ t | � | _ | S )a0 Build the parser from the various parts. Assigns a value to each of the following attributes on the class instance: * **`Markdown.preprocessors`** ([`Registry`][markdown.util.Registry]) -- A collection of [`preprocessors`][markdown.preprocessors]. * **`Markdown.parser`** ([`BlockParser`][markdown.blockparser.BlockParser]) -- A collection of [`blockprocessors`][markdown.blockprocessors]. * **`Markdown.inlinePatterns`** ([`Registry`][markdown.util.Registry]) -- A collection of [`inlinepatterns`][markdown.inlinepatterns]. * **`Markdown.treeprocessors`** ([`Registry`][markdown.util.Registry]) -- A collection of [`treeprocessors`][markdown.treeprocessors]. * **`Markdown.postprocessors`** ([`Registry`][markdown.util.Registry]) -- A collection of [`postprocessors`][markdown.postprocessors]. This method could be redefined in a subclass to build a custom parser which is made up of a different combination of processors and patterns. ) r � preprocessorsr �parserr �inlinePatternsr �treeprocessorsr �postprocessors)rF s rH r? zMarkdown.build_parser� sI � �* 1�� 6���(��.�� � 2�4� 8��� 2�4� 8��� 2�4� 8���� rJ c � � |D ]� }t |t � r"| j ||j |i � � }t |t � rV|j | � t j d|j j �d|j j �d�� ��|���t dj |j j |j j t j t j � � � | S )a� Load a list of extensions into an instance of the `Markdown` class. Arguments: extensions (list[Extension | str]): A list of extensions. If an item is an instance of a subclass of [`markdown.extensions.Extension`][], the instance will be used as-is. If an item is of type `str`, it is passed to [`build_extension`][markdown.Markdown.build_extension] with its corresponding `configs` and the returned instance of [`markdown.extensions.Extension`][] is used. configs (dict[str, dict[str, Any]]): Configuration settings for extensions. z Successfully loaded extension "r1 z".z*Extension "{}.{}" must be of type: "{}.{}") � isinstance�str�build_extensionr8 r �extendMarkdown�logger�debug� __class__� __module__�__name__� TypeError�format)rF r4 r6 �exts rH rC zMarkdown.registerExtensions� s� � �$ � �C��#�s�#��*�*�3�� � �C��0D�E���#�y�)��"�"�4�(�� � ��}�}�/�/�� � �1G�1G�I�� � � �@�G�G�� � �0�0�#�-�-�2H�2H�!�,�,�i�.@�.@��� � � � rJ c � � t |� }t j � D �cg c] }|j |k( s�|�� }}|r|d j � } |d i |��S d|v r|j dd� n|df\ }} t j |� }t j d|z � |r t ||� d i |��S |j d i |��S c c}w # t $ r#}d|z } | f|j dd z |_ � d}~ww xY w# t $ r5}|j d } d|�d | ��} | f|j dd z |_ � d}~ww xY w) a� Build extension from a string name, then return an instance using the given `configs`. Arguments: ext_name: Name of extension as a string. configs: Configuration settings for extension. Returns: An instance of the extension with the given configuration settings. First attempt to load an entry point. The string name must be registered as an entry point in the `markdown.extensions` group which points to a subclass of the [`markdown.extensions.Extension`][] class. If multiple distributions have registered the same name, the first one found is returned. If no entry point is found, assume dot notation (`path.to.module:ClassName`). Load the specified class and return an instance. If no class is specified, import the module and call a `makeExtension` function and return the [`markdown.extensions.Extension`][] instance returned by that function. r �:r r3 z,Successfully imported extension module "%s".z Failed loading extension "%s".Nz Failed to initiate extension 'z': � )�dictr �get_installed_extensions�name�load�split� importlib� import_modulerV rW � ImportError�args�getattr� makeExtension�AttributeError) rF �ext_namer6 �ep� entry_pointsr] � class_name�module�e�messages rH rT zMarkdown.build_extension� s\ � �& �w�-��%)�%B�%B�%D�\�r����S[�H[��\� �\� � �q�/�&�&�(�C��>��>� !� :=�� �x�~�~�c�1� 5�x�Y[�n� ��*� � �,�,�X�6�F� �L�L�>��I� � �.�7�6�:�.�9��9� 9� �+�v�+�+�6�g�6�6��1 ]�� � �6��A�G� �Z�!�&�&���*�,�A�F� �� �� "� ��&�&��)��(0�'�;��!��a�f�f�Q�R�j�0����� �s: �C �C �8-C �:D � C=� C8�8C=� D>� 0D9�9D>c �< � | j j |� | S )a� Register an extension as having a resettable state. Arguments: extension: An instance of the extension to register. This should get called once by an extension during setup. A "registered" extension's `reset` method is called by [`Markdown.reset()`][markdown.Markdown.reset]. Not all extensions have or need a resettable state, and so it should not be assumed that all extensions are "registered." )r< �append�rF � extensions rH �registerExtensionzMarkdown.registerExtension� s � � �!�!�(�(��3�� rJ c �� � | j j � | j j � | j D ] }t |d� s�|j � �! | S )z� Resets all state variables to prepare the parser instance for new input. Called once upon creation of a class instance. Should be called manually between calls to [`Markdown.convert`][markdown.Markdown.convert]. rE )rB rE r@ �clearr< �hasattrrv s rH rE zMarkdown.reset sT � � ��� � � � ��� � � � �2�2� "�I��y�'�*����!� "� � rJ c � � |j � j d� | _ | j | j | _ | S # t $ ry}t | j j � � }|j � d| j �dddj |� z dz �d�}|f|j dd z |_ � d}~ww xY w) z� Set the output format for the class instance. Arguments: format: Must be a known value in `Markdown.output_formats`. �145zInvalid Output Format: "z". Use one of �"z", "r1 r N) �lower�rstripr7 r � serializer�KeyError�list�keys�sort�joinri )rF r\ rr � valid_formatsrs s rH rD zMarkdown.set_output_format s� � � $�\�\�^� 2� 2�5� 9��� � "� 1� 1�$�2D�2D� E�D�O� � �� � � ��!4�!4�!9�!9�!;� <�M� � � � ��%�%�����]�3�3�c�9�;�G� �Z�!�&�&���*�,�A�F� �� �s � A � C�A4C�Cc �z � t |t � r+|j � j d� | j v S y)z� Check if the given `tag` is a block level HTML tag. Returns `True` for any string listed in `Markdown.block_level_elements`. A `tag` which is not a string always returns `False`. �/F)rR rS r r� r; )rF �tags rH �is_block_levelzMarkdown.is_block_level. s3 � � �c�3� ��9�9�;�%�%�c�*�d�.G�.G�G� G�rJ c � � |j � sy t |� }|j d� | _ | j D ]" }|j | j � | _ �$ | j j | j � j � }| j D ] }|j |� }|��|}� | j |� }| j ri |j d| j z � t! | j � z dz }|j# d| j z � } ||| j � }| j( D ] } | j |� }� |j � S # t $ r}|xj dz c_ � d}~ww xY w# t$ $ rV}|j � j' d| j z � rd}n t% d |j � z � |�Y d}~��d}~ww xY w) a� Convert a Markdown string to a string in the specified output format. Arguments: source: Markdown formatted text as Unicode or ASCII string. Returns: A string in the specified output format. Markdown parsing takes place in five steps: 1. A bunch of [`preprocessors`][markdown.preprocessors] munge the input text. 2. A [`BlockParser`][markdown.blockparser.BlockParser] parses the high-level structural elements of the pre-processed text into an [`ElementTree`][xml.etree.ElementTree.ElementTree] object. 3. A bunch of [`treeprocessors`][markdown.treeprocessors] are run against the [`ElementTree`][xml.etree.ElementTree.ElementTree] object. One such `treeprocessor` ([`markdown.treeprocessors.InlineProcessor`][]) runs [`inlinepatterns`][markdown.inlinepatterns] against the [`ElementTree`][xml.etree.ElementTree.ElementTree] object, parsing inline markup. 4. Some [`postprocessors`][markdown.postprocessors] are run against the text after the [`ElementTree`][xml.etree.ElementTree.ElementTree] object has been serialized into text. 5. The output is returned as a string. r3 z/. -- Note: Markdown only accepts Unicode input!N� z<%s>� z</%s>z<%s />z4Markdown failed to strip top-level tags. Document=%r)�striprS �UnicodeDecodeError�reasonre �linesrL �runrM � parseDocument�getrootrO r� r> �index�doc_tag�len�rindex� ValueError�endswithrP ) rF �sourcerr �prep�root� treeprocessor�newRoot�output�start�end�pps rH �convertzMarkdown.convert; s� � �4 �|�|�~�� ���[�F� �\�\�$�'�� ��&�&� .�D� ���$�*�*�-�D�J� .� �{�{�(�(����4�<�<�>�� "� 0� 0� �M�#�'�'��-�G��"� �� � � � ��&�� � !� !� R� � � ��T�\�\�)�+�-0�� � �->�?�AB�C�� �m�m�G�d�l�l�$:�;�� ��c�*�0�0�2�� �%�%� $�B��V�V�F�^�F� $� �|�|�~� ��Q "� � �H�H�I� I�H� �� ��6 � R��<�<�>�*�*�8�d�l�l�+B�C� �F� %� &9�;A�<�<�>�&J� K�PQ�R� �� R�s1 � E7 � A(F �7 F� F�F� G=�'A G8�8G=Nc �� � |xs d}|ret |t � rt j |d|�� }n t j |� |� }|j � }|j � n t j j � }|j d� }| j |� }|r~t |t � r<t j |d|d�� }|j |� |j � | S t j |� } ||d�� }|j |� | S |j |d� }t j j j |� | S ) a� Converts a Markdown file and returns the HTML as a Unicode string. Decodes the file using the provided encoding (defaults to `utf-8`), passes the file content to markdown, and outputs the HTML to either the provided stream or the file with provided name, using the same encoding as the source file. The [`xmlcharrefreplace`](https://docs.python.org/3/library/codecs.html#error-handlers) error handler is used when encoding the output. **Note:** This is the only place that decoding and encoding of Unicode takes place in Python-Markdown. (All other code is Unicode-in / Unicode-out.) Arguments: input: File object or path. Reads from `stdin` if `None`. output: File object or path. Writes to `stdout` if `None`. encoding: Encoding of input and output files. Defaults to `utf-8`. zutf-8�r)�mode�encodingu �w�xmlcharrefreplace)r� �errors)r� )rR rS �codecs�open� getreader�read�close�sys�stdin�lstripr� �write� getwriter�encode�stdout�buffer) rF �inputr� r� � input_file�textr � output_file�writers rH � convertFilezMarkdown.convertFile� s; � �6 �&�w�� ��%��%� #�[�[��S�8� L� � 7�V� -� -�h� 7�� >� � �?�?�$�D� � � � ��9�9�>�>�#�D��{�{�8�$�� �|�|�D�!�� ��&�#�&� $�k�k�&�#�3;�1D� F� � �!�!�$�'��!�!�#� � � �)�)�(�3�� $�V�4G� H� ��!�!�$�'� � � �;�;�x�)<�=�D� �J�J� � � #� #�D� )�� rJ )�returnr )r4 zSequence[Extension | str]r6 z Mapping[str, dict[str, Any]]r� r )rm rS r6 zMapping[str, Any]r� r )rw r r� r )r\ rS r� r )r� r r� �bool)r� rS r� rS )NNN)r� �str | BinaryIO | Noner� r� r� z str | Noner� r )rZ rY � __qualname__�__doc__r� r r r �__annotations__rI r? rC rT rx rE rD r� r� r� r` rJ rH r r . s� � � �< �G� !�!�E�N�A� �� )�V�8"�-�"� .�"� � "�H3�j � � �. �G �V (,�(,� #� ?�$�?� &�?� � ?� � ?rJ r c �: � t di |��}|j | � S )a5 Convert a markdown string to HTML and return HTML as a Unicode string. This is a shortcut function for [`Markdown`][markdown.Markdown] class to cover the most basic use case. It initializes an instance of [`Markdown`][markdown.Markdown], loads the necessary extensions and runs the parser on the given text. Arguments: text: Markdown formatted text as Unicode or ASCII string. Keyword arguments: **kwargs: Any arguments accepted by the Markdown class. Returns: A string in the specified output format. r` )r r� )r� rG �mds rH r r � s � �$ � �F� �B� �:�:�d� �rJ c � � t di | ��}|j | j dd� | j dd� | j dd� � y)aE Read Markdown text from a file and write output to a file or a stream. This is a shortcut function which initializes an instance of [`Markdown`][markdown.Markdown], and calls the [`convertFile`][markdown.Markdown.convertFile] method rather than [`convert`][markdown.Markdown.convert]. Keyword arguments: input (str | BinaryIO): A file name or readable object. output (str | BinaryIO): A file name or writable object. encoding (str): Encoding of input and output. **kwargs: Any arguments accepted by the `Markdown` class. r� Nr� r� r` )r r� r8 )rG r� s rH r r � sF � � � �F� �B��N�N�6�:�:�g�t�,��:�:�h��-��:�:�j�$�/�1rJ )r� rS rG r r� rS )rG r )(� __future__r r� r� �loggingrf �typingr r r r r r r r3 r rL r �blockprocessorsr rO r �inlinepatternsr rP r r4 r � serializersr r r �xml.etree.ElementTreer �__all__� getLoggerrV r r r r` rJ rH �<module>r� su ��( #� � � � � V� V� V� � .� /� 0� 0� 0� !� 8� &��-� 6�� �� � �:� &��U� U�p � �,1rJ
© 2026 UnknownSec