403Webshell
Server IP : 127.0.0.1  /  Your IP : 216.73.216.109
Web Server : Apache/2.4.54 (Win64) OpenSSL/1.1.1q PHP/8.1.10
System : Windows NT DESKTOP-E5T4RUN 10.0 build 19045 (Windows 10) AMD64
User : SERVERWEB ( 0)
PHP Version : 8.1.10
Disable Function : NONE
MySQL : OFF |  cURL : ON |  WGET : OFF |  Perl : OFF |  Python : OFF |  Sudo : OFF |  Pkexec : OFF
Directory :  C:/cygwin64/lib/python3.9/site-packages/babel/messages/__pycache__/

Upload File :
current_dir [ Writeable] document_root [ Writeable]

 

Command :

[ Back ]     

Current File : C:/cygwin64/lib/python3.9/site-packages/babel/messages/__pycache__/extract.cpython-39.opt-1.pyc
a

�4dh~�@snUdZddlmZddlZddlZddlZddlZddlmZm	Z	m
Z
mZmZm
Z
ddlmZddlmZddlmZmZmZmZmZddlmZmZdd	lmZmZmZe�rdd
lmZm Z ddl!m"Z"m#Z#m$Z$ddl%m&Z&m'Z'm(Z(Gd
d�de(dd�Z)Gdd�de(dd�Z*Gdd�de#e+e$e+e �Z,e-e.e-e.e.fBe-e.e/fBdfdBZ0de1d<e-e/e.e/e-e/dfBe2e/e/dBfZ3de1d<e-e.e/e-e/dfBe2e/e/dBfZ4de1d<ee,ee+Bee/e0fe	e/ee/efgee4fZ5de1d<e5e/BZ6de1d<dZ7de1d<dddddd d!dd"d#d$�
Z8d%e1d&<d'gZ9d(e1d)<d*d+d,�d-d.�Z:d/d0d1�d2d3�Z;de9de8d4dddfd5d6d7d8d9d:d0d;d<d=�	d>d?�Z<dad/d6d@d:d8d9d0d5d<dA�	dBdC�Z=e8d4ddfdd/d8d9dDd0dEdF�dGdH�Z>e8d4ddfddd8d9dDd0dIdJ�dKdL�Z?dd8d9dMdEdN�dOdP�Z@dQd8d9ddIdN�dRdS�ZAdTdTdUdVdW�dXdY�ZBdbdd8d9ddUdId[�d\d]�ZCdcdTd8d9ddUdId^�d_d`�ZDdS)daf
    babel.messages.extract
    ~~~~~~~~~~~~~~~~~~~~~~

    Basic infrastructure for extracting localizable messages from source files.

    This module defines an extensible system for collecting localizable message
    strings from a variety of sources. A native extractor for Python source
    files is builtin, extractors for other sources can be added using very
    simple plugins.

    The main entry points into the extraction functionality are the functions
    `extract_from_dir` and `extract_from_file`.

    :copyright: (c) 2013-2023 by the Babel Team.
    :license: BSD, see LICENSE for more details.
�)�annotationsN)�Callable�
Collection�	Generator�Iterable�Mapping�MutableSequence)�relpath)�dedent)�COMMENT�NAME�OP�STRING�generate_tokens)�
TYPE_CHECKING�Any)�parse_encoding�parse_future_flags�	pathmatch)�IO�Protocol)�
SupportsItems�SupportsRead�SupportsReadline)�Final�	TypeAlias�	TypedDictc@seZdZUded<dS)�
_PyOptions�str�encodingN��__name__�
__module__�__qualname__�__annotations__�r%r%�:/usr/lib/python3.9/site-packages/babel/messages/extract.pyr-s
rF)�totalc@s.eZdZUded<ded<ded<ded<dS)�
_JSOptionsrr�bool�jsx�template_string�parse_template_stringNr r%r%r%r&r(0s
r(c@s.eZdZd
dddd�dd�Zdd�dd�Zd	S)�_FileObj.�int)�_FileObj__offset�_FileObj__whence�returncCsdS�Nr%)�selfr/r0r%r%r&�seek7�z
_FileObj.seek)r1cCsdSr2r%)r3r%r%r&�tell8r5z
_FileObj.tellN).)r!r"r#r4r6r%r%r%r&r-6sr-.r�_Keyword�_FileExtractionResult�_ExtractionResult�_CallableExtractionMethod�_ExtractionMethodzbabel.extractorsz
Final[str]�
GROUP_NAME)��)r>)r>�)�r=�cr>)r@r>r?)
�_�gettext�ngettextZugettextZ	ungettext�dgettext�	dngettextZN_�pgettext�	npgettextzdict[str, _Keyword]�DEFAULT_KEYWORDS)z**.py�pythonzlist[tuple[str, str]]�DEFAULT_MAPPINGzMutableSequence[str]z
Iterable[str])�comments�tagscs(dd��fdd�}t||�|dd�<dS)z�Helper function for `extract` that strips comment tags from strings
    in a list of comment lines.  This functions operates in-place.
    r)�linecs0�D]&}|�|�r|t|�d���Sq|Sr2)�
startswith�len�strip)rN�tag�rMr%r&�_stripas
z#_strip_comment_tags.<locals>._stripN)�map)rLrMrTr%rSr&�_strip_comment_tags]srVzstr | os.PathLike[str]r))�dirpathr1cCs"tj�|�}|�d�p|�d�S)N�.rB)�os�path�basenamerO)rW�subdirr%r%r&�default_directory_filterisr]r%zstr | os.PathLike[str] | NonezIterable[tuple[str, str]]z)SupportsItems[str, dict[str, Any]] | NonezMapping[str, _Keyword]zCollection[str]z3Callable[[str, str, dict[str, Any]], object] | NonezCallable[[str], bool] | Nonez,Generator[_FileExtractionResult, None, None])	�dirname�
method_map�options_map�keywords�comment_tags�callback�strip_comment_tags�directory_filterr1c
#s�|durt��}|duri}�dur(t�tj�|�}t�|�D]v\�}	}
��fdd�|	D�|	dd�<|	��|
��|
D]:}tj��|��tj	d�}t
||||||||d�EdHqxq>dS)a$
Extract messages from any source files found in the given directory.

    This function generates tuples of the form ``(filename, lineno, message,
    comments, context)``.

    Which extraction method is used per file is determined by the `method_map`
    parameter, which maps extended glob patterns to extraction method names.
    For example, the following is the default mapping:

    >>> method_map = [
    ...     ('**.py', 'python')
    ... ]

    This basically says that files with the filename extension ".py" at any
    level inside the directory should be processed by the "python" extraction
    method. Files that don't match any of the mapping patterns are ignored. See
    the documentation of the `pathmatch` function for details on the pattern
    syntax.

    The following extended mapping would also use the "genshi" extraction
    method on any file in "templates" subdirectory:

    >>> method_map = [
    ...     ('**/templates/**.*', 'genshi'),
    ...     ('**.py', 'python')
    ... ]

    The dictionary provided by the optional `options_map` parameter augments
    these mappings. It uses extended glob patterns as keys, and the values are
    dictionaries mapping options names to option values (both strings).

    The glob patterns of the `options_map` do not necessarily need to be the
    same as those used in the method mapping. For example, while all files in
    the ``templates`` folders in an application may be Genshi applications, the
    options for those files may differ based on extension:

    >>> options_map = {
    ...     '**/templates/**.txt': {
    ...         'template_class': 'genshi.template:TextTemplate',
    ...         'encoding': 'latin-1'
    ...     },
    ...     '**/templates/**.html': {
    ...         'include_attrs': ''
    ...     }
    ... }

    :param dirname: the path to the directory to extract messages from.  If
                    not given the current working directory is used.
    :param method_map: a list of ``(pattern, method)`` tuples that maps of
                       extraction method names to extended glob patterns
    :param options_map: a dictionary of additional options (optional)
    :param keywords: a dictionary mapping keywords (i.e. names of functions
                     that should be recognized as translation functions) to
                     tuples that specify which of their arguments contain
                     localizable strings
    :param comment_tags: a list of tags of translator comments to search for
                         and include in the results
    :param callback: a function that is called for every file that message are
                     extracted from, just before the extraction itself is
                     performed; the function is passed the filename, the name
                     of the extraction method and and the options dictionary as
                     positional arguments, in that order
    :param strip_comment_tags: a flag that if set to `True` causes all comment
                               tags to be removed from the collected comments.
    :param directory_filter: a callback to determine whether a directory should
                             be recursed into. Receives the full directory path;
                             should return True if the directory is valid.
    :see: `pathmatch`
    Ncs"g|]}�tj��|��r|�qSr%)rYrZ�join)�.0r\�re�rootr%r&�
<listcomp>�s�z$extract_from_dir.<locals>.<listcomp>�/)rW)rY�getcwdr]rZ�abspath�walk�sortrf�replace�sep�check_and_call_extract_file)
r^r_r`rarbrcrdreZabsname�dirnames�	filenames�filename�filepathr%rhr&�extract_from_diros2O��rwz"SupportsItems[str, dict[str, Any]])	rvr_r`rcrarbrdrWr1c	cs�t||�}|D]t\}	}
t|	|�s"qi}|��D]\}}
t||�r.|
}q.|rV|||
|�t|
|||||d�D]}|g|�RVqjq�qdS)aChecks if the given file matches an extraction method mapping, and if so, calls extract_from_file.

    Note that the extraction method mappings are based relative to dirpath.
    So, given an absolute path to a file `filepath`, we want to check using
    just the relative path from `dirpath` to `filepath`.

    Yields 5-tuples (filename, lineno, messages, comments, context).

    :param filepath: An absolute path to a file that exists.
    :param method_map: a list of ``(pattern, method)`` tuples that maps of
                       extraction method names to extended glob patterns
    :param options_map: a dictionary of additional options (optional)
    :param callback: a function that is called for every file that message are
                     extracted from, just before the extraction itself is
                     performed; the function is passed the filename, the name
                     of the extraction method and and the options dictionary as
                     positional arguments, in that order
    :param keywords: a dictionary mapping keywords (i.e. names of functions
                     that should be recognized as translation functions) to
                     tuples that specify which of their arguments contain
                     localizable strings
    :param comment_tags: a list of tags of translator comments to search for
                         and include in the results
    :param strip_comment_tags: a flag that if set to `True` causes all comment
                               tags to be removed from the collected comments.
    :param dirpath: the path to the directory to extract messages from.
    :return: iterable of 5-tuples (filename, lineno, messages, comments, context)
    :rtype: Iterable[tuple[str, int, str|tuple[str], list[str], str|None]
    )rarb�optionsrdN)r	r�items�extract_from_file)rvr_r`rcrarbrdrWru�pattern�methodrxZopatternZodictZ
message_tupler%r%r&rr�s&(


�
rrzMapping[str, Any] | Nonezlist[_ExtractionResult])r|rurarbrxrdr1c	CsP|dkrgSt|d��&}tt||||||��Wd�S1sB0YdS)aExtract messages from a specific file.

    This function returns a list of tuples of the form ``(lineno, message, comments, context)``.

    :param filename: the path to the file to extract messages from
    :param method: a string specifying the extraction method (.e.g. "python")
    :param keywords: a dictionary mapping keywords (i.e. names of functions
                     that should be recognized as translation functions) to
                     tuples that specify which of their arguments contain
                     localizable strings
    :param comment_tags: a list of translator tags to search for and include
                         in the results
    :param strip_comment_tags: a flag that if set to `True` causes all comment
                               tags to be removed from the collected comments.
    :param options: a dictionary of additional options (optional)
    :returns: list of tuples of the form ``(lineno, message, comments, context)``
    :rtype: list[tuple[int, str|tuple[str], list[str], str|None]
    �ignore�rbN)�open�list�extract)r|rurarbrxrd�fileobjr%r%r&rzs�rzz(Generator[_ExtractionResult, None, None])r|r�rarbrxrdr1ccs�d}t|�r|}n�d|vs"d|vr|d|vrT|�d�}|d|�||dd�}}	n|�dd�\}}	tt|ii|	g�|	�}ndzddlm}
Wnty�Yn$0|
�t	|�D]}|j
dd�}q�q�|dur�ttt
d	�}|�|�}|dur�td
|����|||��||�p
id�}
|
D�]l\}}}}|�r6||�p8dnd}t|ttf��sP|g}|�sZ�qd}g}d
}t|�}|D]d}t|t��r�||dd}�qr||k�r�d}�q�||d}|du�r�d}�q�|�|��qr|�r�qt|dt��r|dd}n|dd}||�sDt|dd��p&d}tj�|�d|�d���qt|�}t|�dk�rb|d}|�rrt||�||||fV�qdS)a�Extract messages from the given file-like object using the specified
    extraction method.

    This function returns tuples of the form ``(lineno, message, comments, context)``.

    The implementation dispatches the actual extraction to plugins, based on the
    value of the ``method`` parameter.

    >>> source = b'''# foo module
    ... def run(argv):
    ...    print(_('Hello, world!'))
    ... '''

    >>> from io import BytesIO
    >>> for message in extract('python', BytesIO(source)):
    ...     print(message)
    (3, u'Hello, world!', [], None)

    :param method: an extraction method (a callable), or
                   a string specifying the extraction method (.e.g. "python");
                   if this is a simple name, the extraction function will be
                   looked up by entry point; if it is an explicit reference
                   to a function (of the form ``package.module:funcname`` or
                   ``package.module.funcname``), the corresponding function
                   will be imported and used
    :param fileobj: the file-like object the messages should be extracted from
    :param keywords: a dictionary mapping keywords (i.e. names of functions
                     that should be recognized as translation functions) to
                     tuples that specify which of their arguments contain
                     localizable strings
    :param comment_tags: a list of translator tags to search for and include
                         in the results
    :param options: a dictionary of additional options (optional)
    :param strip_comment_tags: a flag that if set to `True` causes all comment
                               tags to be removed from the collected comments.
    :raise ValueError: if the extraction method is not registered
    :returns: iterable of tuples of the form ``(lineno, message, comments, context)``
    :rtype: Iterable[tuple[int, str|tuple[str], list[str], str|None]
    N�:rXr=r)�working_setT)Zrequire)r}rJZ
javascriptzUnknown extraction method )rx�r=F�namez	(unknown)z�: warning: Empty msgid.  It is reserved by GNU gettext: gettext("") returns the header entry with meta information, not the empty string.
)�callable�rfind�split�getattr�
__import__Z
pkg_resourcesr��ImportErrorZiter_entry_pointsr<�load�extract_nothing�extract_python�extract_javascript�get�
ValueError�keys�
isinstancer��tuplerP�append�sys�stderr�writerV)r|r�rarbrxrd�funcZlastdot�module�attrnamer�Zentry_pointZbuiltin�results�lineno�funcname�messagesrL�spec�contextZmsgsZinvalidZ
last_index�index�messageZfirst_msg_indexrur%r%r&r�>s�/
 ��
�


�
r�zMapping[str, Any])r�rarbrxr1cCsgS)zdPseudo extractor that does not actually extract anything, but simply
    returns an empty list.
    r%)r�rarbrxr%r%r&r��s	r�z	IO[bytes]c#s,d}}}d}g}g}	g}
d}}d}
t��p:|�dd��t���}��fdd�}t|�}|D�]�\}}\}}}}|dkr�|tkr�|dvr�d	}q`|tkr�|d
kr�|r�d}q`|r�|}|d7}q`|r�|tkr�|dkr�d}q`q`|dk�r\|tk�r\|dd���}|�r*|
dd
|dk�r*|
�||f�q`|D]*}
|�	|
��r.d	}|
�||f��q&�q.q`|�r�|d
k�r�|tk�o|||v}|tk�r�|dk�s�|�rB|�r�|	�d�
|��|dd�=n
|	�d�t|	�dk�r�t|	�n|	d
}	|
�r|
dd
|dk�rg}
|||	dd�|
D�fVd}}}d}g}	g}
d}|�r�|}n�|t
k�rnt|�|�}|du�r�|�|�nd|tk�r&|dk�r&|�r�|	�d�
|��|dd�=n
|	�d�|
�r&|
��\}}|
�|d|f�q`|d
k�r�|tk�r�|dk�r�|d8}q`|�r|dk�rd}q`|tkr`||vr`|}q`dS)acExtract messages from Python source code.

    It returns an iterator yielding tuples in the following form ``(lineno,
    funcname, message, comments)``.

    :param fileobj: the seekable, file-like object the messages should be
                    extracted from
    :param keywords: a list of keywords (i.e. function names) that should be
                     recognized as translation functions
    :param comment_tags: a list of translator tags to search for and include
                         in the results
    :param options: a dictionary of additional options (optional)
    :rtype: ``iterator``
    N���FrzUTF-8cs������Sr2)�readline�decoder%�rr�r%r&�<lambda>�r5z extract_python.<locals>.<lambda>)�def�classT�(r=r�r�)�cSsg|]}|d�qSr�r%�rgZcommentr%r%r&rj$r5z"extract_python.<locals>.<listcomp>�,)rr�rrrr
rrQr�rOrfrPr�r�_parse_python_string�pop)r�rarbrxr�r��message_lineno�
call_stack�bufr��translator_commentsZin_defZin_translator_comments�comment_tag�future_flagsZ	next_line�tokens�tok�valuerB�nested�valZ
old_linenoZold_commentr%r�r&r��s�

�
��



r�rr.z
str | None)r�rr�r1cCs�tdt|��d|��ddtj|B�}t|tj�r�|j}t|tj�rH|jSt|tj	�r�t
dd�|jD��r~d�dd�|jD��St
d	d�|jD��r�d�d
d�|jD��SdS)Nz	# coding=�
z<string>�evalcss|]}t|tj�VqdSr2)r��ast�Str�rgZnoder%r%r&�	<genexpr>Tr5z'_parse_python_string.<locals>.<genexpr>r�css|]}|jVqdSr2)�sr�r%r%r&r�Ur5css|]}t|tj�VqdSr2)r�r�ZConstantr�r%r%r&r�Vr5css|]}t|j�VqdSr2)rr�r�r%r%r&r�Wr5)
�compilerr�Z
PyCF_ONLY_ASTr�Z
Expression�bodyr�r�Z	JoinedStr�all�valuesrf)r�rr��coder�r%r%r&r�Fs �r�r=)r�rarbrxr�r1ccsLddlm}m}m}d}}	g}
d}g}d}
|�dd�}d}d}tdd	�|D��}||���|�|�d
d�|�dd�||d
�D�]�}|r�|r�|jdkr�|jdkr�|j	}	||j
�g}
d}|dd|j	�}|�d�r�|s�|jdkr�t|j
||||j	�EdH�nH|jdk�r*|j
dk�r*|�rB|j	}	|d7}�n|dk�r�|jdk�r�|j
dd���}|�r�|dd|j	dk�r�|�
|j	|f�q~|D],}|�|��r�|�
|j	|��f��qB�q��n�|jdk�rdg}|j
dd���}|D]�}|�|��r�|��}|�rV|d��|d<td�|dd�����|dd�<t|�D]\}}|�
|j	||f��q6�qB�qސn�|�r�|dk�r�|jdk�r,|j
dk�r,|du�r�|
�
|�t|
�dk�r�t|
�}
n|
�r�|
d}
nd}
|�r�|dd|	dk�r�g}|
du�r|	||
dd�|D�fVd}}	}d}
g}g}
d}n�|jdv�rb||j
�}|
�r\|�pPd|}d}
n|}nR|jdk�rB|j
dk�r�|du�r�|
�
|�d}n
|
�
d�d}
n|j
dk�rBd}
n�|dk�r�|jdk�r�|j
dk�r�|d8}n`|�r�|dk�r�d}nJ|dk�rB|jdk�rB|j
|v�rB|du�s<|jdk�s<|j
dk�rB|j
}|}q~dS) a�Extract messages from JavaScript source code.

    :param fileobj: the seekable, file-like object the messages should be
                    extracted from
    :param keywords: a list of keywords (i.e. function names) that should be
                     recognized as translation functions
    :param comment_tags: a list of translator tags to search for and include
                         in the results
    :param options: a dictionary of additional options (optional)
                    Supported options are:
                    * `jsx` -- set to false to disable JSX/E4X support.
                    * `template_string` -- if `True`, supports gettext(`key`)
                    * `parse_template_string` -- if `True` will parse the
                                                 contents of javascript
                                                 template strings.
    :param lineno: line number offset (for parsing embedded fragments)
    r)�Token�tokenize�unquote_stringNFrzutf-8r�css|]}d|vVqdS)rXNr%)rg�kwr%r%r&r�}r5z%extract_javascript.<locals>.<genexpr>r*Tr+)r*r+�dottedr�r��operatorr�r,r�r=Zlinecommentr>Zmultilinecomment���r�cSsg|]}|d�qSr�r%r�r%r%r&rj�r5z&extract_javascript.<locals>.<listcomp>)�stringr+r�r��+�function)�babel.messages.jslexerr�r�r�r��any�readr��typer�r�r,rQr�rO�
splitlinesr
rf�	enumeraterPr�)r�rarbrxr�r�r�r�r�r�r�Z
last_argumentr�Zconcatenate_nextrZ
last_tokenr�r��tokenr�r��lines�offsetrNZ	new_valuer%r%r&r�\s�

������"�




�
�



�
����r�)r+rarbrxr�r1ccs�ddlm}d}d}d}d}	|dd�D]�}
|s>|
dvr>|
}n||
krR|d	krRd}|r^|	|
7}	|s�|
d
kr||dkr||d7}nf|r�|
dkr�|d8}|dkr�|	r�|	dd�}	t�|	���}t|||||�EdH|t|�|	��7}d}	|
}q(dS)
a�Parse JavaScript template string.

    :param template_string: the template string to be parsed
    :param keywords: a list of keywords (i.e. function names) that should be
                     recognized as translation functions
    :param comment_tags: a list of translator tags to search for and include
                         in the results
    :param options: a dictionary of additional options (optional)
    :param lineno: starting line number (optional)
    r)�line_reNFr�r=r�)�"�'�`z\\�{�$�})r�r��io�BytesIO�encoder�rP�findall)r+rarbrxr�r�Zprev_character�levelZ
inside_strZexpression_contents�	characterZ
fake_file_objr%r%r&r,�s0
r,)N)r=)r=)E�__doc__Z
__future__rr�r�rYr��collections.abcrrrrrrZos.pathr	�textwrapr
r�rrr
rr�typingrrZ
babel.utilrrrrrZ	_typeshedrrrZtyping_extensionsrrrrr(�bytesr-r�r.rr7r$r�r8r9r:r;r<rIrKrVr]rwrrrzr�r�r�r�r�r,r%r%r%r&�<module>s� 0.,&���
� u� C�%�
s��

Youez - 2016 - github.com/yon3zu
LinuXploit