403Webshell
Server IP : 35.80.110.71  /  Your IP : 216.73.216.221
Web Server : Apache/2.4.58 (Ubuntu)
System : Linux ip-172-31-21-44 6.17.0-1019-aws #19~24.04.1-Ubuntu SMP Tue Jun 23 18:53:06 UTC 2026 x86_64
User : ubuntu ( 1000)
PHP Version : 8.3.31
Disable Function : NONE
MySQL : OFF  |  cURL : ON  |  WGET : ON  |  Perl : ON  |  Python : OFF  |  Sudo : ON  |  Pkexec : OFF
Directory :  /lib/python3/dist-packages/fs/__pycache__/

Upload File :
current_dir [ Writeable ] document_root [ Writeable ]

 

Command :

[ Back ]     

Current File : /lib/python3/dist-packages/fs/__pycache__/walk.cpython-312.pyc
�

��obUk���dZddlmZddlZddlmZmZmZddlm	Z	ddl
mZddlm
Z
mZmZej r-dd	lmZmZmZmZmZmZmZmZmZmZdd
lmZddlmZeeege fZ!ejDdd
��Z#edd�Z$	Gd�de%�Z&Gd�dejNe#�Z(e&�Z)e)jTZ*e)jVZ,e)j:Z-e)j\Z/y)z�Machinery for walking a filesystem.

*Walking* a filesystem means recursively visiting a directory and
any sub-directories. It is a fairly common requirement for copying,
searching etc. See :ref:`walking` for details.
�)�unicode_literalsN)�defaultdict�deque�
namedtuple�)�	make_repr)�FSError)�abspath�combine�normpath)
�Any�Callable�
Collection�Iterator�List�MutableMapping�Optional�Text�Tuple�Type)�FS)�Info�_Fr)�bound�Stepzpath, dirs, filesc����eZdZdZ								d�fd�	Zed��Zed��Zed��Zed��Z	d�Z
	dd�Zd	�Zd
�Z
d�Zd�Zd
�Z	dd�Z		dd�Zdd�Zdd�Z		dd�Z	dd�Z	dd�Z�xZS)�Walkerz>A walker object recursively lists directories in a filesystem.c	�6��|dvrtd��||_|r
|r%td��|r|jn|j}t	|�std��||_||_||_||_	||_
||_||_tt|�?�y)a-Create a new `Walker` instance.

        Arguments:
            ignore_errors (bool): If `True`, any errors reading a
                directory will be ignored, otherwise exceptions will
                be raised.
            on_error (callable, optional): If ``ignore_errors`` is `False`,
                then this callable will be invoked for a path and the
                exception object. It should return `True` to ignore the error,
                or `False` to re-raise it.
            search (str): If ``"breadth"`` then the directory will be
                walked *top down*. Set to ``"depth"`` to walk *bottom up*.
            filter (list, optional): If supplied, this parameter should be
                a list of filename patterns, e.g. ``["*.py"]``. Files will
                only be returned if the final component matches one of the
                patterns.
            exclude (list, optional): If supplied, this parameter should be
                a list of filename patterns, e.g. ``["~*"]``. Files matching
                any of these patterns will be removed from the walk.
            filter_dirs (list, optional): A list of patterns that will be used
                to match directories paths. The walk will only open directories
                that match at least one of these patterns.
            exclude_dirs (list, optional): A list of patterns that will be
                used to filter out directories from the walk. e.g.
                ``['*.svn', '*.git']``.
            max_depth (int, optional): Maximum directory depth to walk.

        )�breadth�depthz#search must be 'breadth' or 'depth'z,on_error is invalid when ignore_errors==Truezon_error must be callableN)�
ValueError�
ignore_errors�_ignore_errors�
_raise_errors�callable�	TypeError�on_error�search�filter�exclude�filter_dirs�exclude_dirs�	max_depth�superr�__init__)
�selfr"r'r(r)r*r+r,r-�	__class__s
         ��)/usr/lib/python3/dist-packages/fs/walk.pyr/zWalker.__init__5s����P�-�-��B�C�C�*����� �!O�P�P�.;�t�*�*��AS�AS�H���!��7�8�8� ��
����������&���(���"���
�f�d�$�&�c��y)z#Ignore dir scan errors when called.T���cls�path�errors   r2r#zWalker._ignore_errorsqs��r3c��y)z%Re-raise dir scan errors when called.Fr5r6s   r2r$zWalker._raise_errorsws��r3c�T�|jd�}|r|jd�dzSdS)zBCalculate the 'depth' of a directory path (i.e. count components).�/rr)�strip�count)r7r8�_paths   r2�_calculate_depthzWalker._calculate_depth}s,���
�
�3���',�u�{�{�3��!�#�3�!�3r3c��t|�S)aBind a `Walker` instance to a given filesystem.

        This *binds* in instance of the Walker to a given filesystem, so
        that you won't need to explicitly provide the filesystem as a
        parameter.

        Arguments:
            fs (FS): A filesystem object.

        Returns:
            ~fs.walk.BoundWalker: a bound walker.

        Examples:
            Use this method to explicitly bind a filesystem instance::

                >>> walker = Walker.bind(my_fs)
                >>> for path in walker.files(filter=['*.py']):
                ...     print(path)
                /foo.py
                /bar.py

            Unless you have written a customized walker class, you will
            be unlikely to need to call this explicitly, as filesystem
            objects already have a ``walk`` attribute which is a bound
            walker object::

                >>> for path in my_fs.walk.files(filter=['*.py']):
                ...     print(path)
                /foo.py
                /bar.py

        )�BoundWalker)r7�fss  r2�bindzWalker.bind�s��F�2��r3c��t|jj|jdf|jdf|j
df|jdf|jdf|jdf|jdf|jdf��	S)NFr)r"r'r(r)r*r+r,r-)rr1�__name__r"r'r(r)r*r+r,r-�r0s r2�__repr__zWalker.__repr__�s�����N�N�#�#��-�-�u�5��m�m�T�*��K�K��+��K�K��&��\�\�4�(��)�)�4�0��+�+�T�2��~�~�t�,�

�
	
r3c�p�|jdk(r|j|||��S|j|||��S)zGet the walk generator.r��
namespaces)r(�
_walk_breadth�_walk_depth)r0rCr8rKs    r2�
_iter_walkzWalker._iter_walk�s@���;�;�)�#��%�%�b�$�:�%�F�F��#�#�B���#�D�Dr3c���|j�'|j|j|j�ry|j�'|j|j|j�sy|j	|||�S)z6Check if a directory should be considered in the walk.F)r,�match�namer+�check_open_dir�r0rCr8�infos    r2�_check_open_dirzWalker._check_open_dir�se�����(�R�X�X�d�6G�6G����-S�����'�����9I�9I�4�9�9�0U���"�"�2�t�T�2�2r3c��y)adCheck if a directory should be opened.

        Override to exclude directories from the walk.

        Arguments:
            fs (FS): A filesystem instance.
            path (str): Path to directory.
            info (Info): A resource info object for the directory.

        Returns:
            bool: `True` if the directory should be opened.

        Tr5rSs    r2rRzWalker.check_open_dir�s��r3c�`�|j�||jk\ry|j|||�S)z0Check if a directory contents should be scanned.F)r-�check_scan_dir)r0rCr8rTr s     r2�_check_scan_dirzWalker._check_scan_dir�s1���>�>�%�%�4�>�>�*A���"�"�2�t�T�2�2r3c��y)a�Check if a directory should be scanned.

        Override to omit scanning of certain directories. If a directory
        is omitted, it will appear in the walk but its files and
        sub-directories will not.

        Arguments:
            fs (FS): A filesystem instance.
            path (str): Path to directory.
            info (Info): A resource info object for the directory.

        Returns:
            bool: `True` if the directory should be scanned.

        Tr5rSs    r2rXzWalker.check_scan_dir�s��"r3c��|j�'|j|j|j�ry|j|j|j�S)aCheck if a filename should be included.

        Override to exclude files from the walk.

        Arguments:
            fs (FS): A filesystem instance.
            info (Info): A resource info object.

        Returns:
            bool: `True` if the file should be included.

        F)r*rPrQr))r0rCrTs   r2�
check_filezWalker.check_file�s?���<�<�#�������t�y�y�(I���x�x����T�Y�Y�/�/r3c#�K�	|j||��D]}|���y#t$r}|j||�s�Yd}~yd}~wwxYw�w)a�Get an iterator of `Info` objects for a directory path.

        Arguments:
            fs (FS): A filesystem instance.
            dir_path (str): A path to a directory on the filesystem.
            namespaces (list): A list of additional namespaces to
                include in the `Info` objects.

        Returns:
            ~collections.Iterator: iterator of `Info` objects for
            resources within the given path.

        rJN)�scandirr	r')r0rC�dir_pathrKrTr9s      r2�_scanzWalker._scan
sQ����(	��
�
�8�
�
�C�
���
�
���	��=�=��5�1��2��	�s)�A
�!�A
�	A�A�A
�A�A
c#�:K�tt|��}tt�}|j	|||��}|D][\}}|�@g}	g}
||D]!}|j
r|	n|
j
|��#t||	|
���||=�H||j
|��]y�w)abWalk the directory structure of a filesystem.

        Arguments:
            fs (FS): A filesystem instance.
            path (str): A path to a directory on the filesystem.
            namespaces (list, optional): A list of additional namespaces
                to add to the `Info` objects.

        Returns:
            collections.Iterator: an iterator of `~fs.walk.Step` instances.

        The return value is an iterator of ``(<path>, <dirs>, <files>)``
        named tuples,  where ``<path>`` is an absolute path to a
        directory, and ``<dirs>`` and ``<files>`` are a list of
        `~fs.info.Info` objects for directories and files in ``<path>``.

        Example:
            >>> walker = Walker(filter=['*.py'])
            >>> for path, dirs, files in walker.walk(my_fs, namespaces=["details"]):
            ...    print("[{}]".format(path))
            ...    print("{} directories".format(len(dirs)))
            ...    total = sum(info.size for info in files)
            ...    print("{} bytes".format(total))
            [/]
            2 directories
            55 bytes
            ...

        rJN)r
rr�listrN�is_dir�appendr)r0rCr8rKr?�dir_info�_walkr_rT�dirs�files�_infos            r2�walkzWalker.walk%s�����H����'���t�$������E�j��A��#�		0�N�H�d��|�����%�h�/�D�E�"�\�\�T�u�<�<�U�C�D��8�T�5�1�1��X�&���"�)�)�$�/�		0�s�BBc#�K�t}|j||��D]*\}}|��	|jr�|||j����,y�w)aDWalk a filesystem, yielding absolute paths to files.

        Arguments:
            fs (FS): A filesystem instance.
            path (str): A path to a directory on the filesystem.

        Yields:
            str: absolute path to files on the filesystem found
            recursively within the given directory.

        �r8N�rrNrcrQ�r0rCr8�_combiner?rTs      r2rhzWalker.filesWsJ�������?�?�2�D�?�9�	1�K�E�4�������u�d�i�i�0�0�	1���"A
�A
�A
c#�K�t}|j||��D]*\}}|��	|js�|||j����,y�w)aPWalk a filesystem, yielding absolute paths to directories.

        Arguments:
            fs (FS): A filesystem instance.
            path (str): A path to a directory on the filesystem.

        Yields:
            str: absolute path to directories on the filesystem found
            recursively within the given directory.

        rlNrmrns      r2rgzWalker.dirsisJ�������?�?�2�D�?�9�	1�K�E�4���D�K�K��u�d�i�i�0�0�	1�rpc#�K�t}|j|||��}|D]\}}|��	|||j�|f���!y�w)a�Walk a filesystem, yielding tuples of ``(<path>, <info>)``.

        Arguments:
            fs (FS): A filesystem instance.
            path (str): A path to a directory on the filesystem.
            namespaces (list, optional): A list of additional namespaces
                to add to the `Info` objects.

        Yields:
            (str, Info): a tuple of ``(<absolute path>, <resource info>)``.

        �r8rKN)rrNrQ)r0rCr8rKrorfr?rTs        r2rTzWalker.info{sP����&�������*��E�� �	7�K�E�4����u�d�i�i�0�$�6�6�	7�s
�%A�Ac#��K�t|g�}|j}|j}t}|j}|j
}	|j}
|j}|j}|	|�}
|r�|�}||||��D]c}|jrE|	|�|
z
dz}|
|||�s�(||f��|||||�s�:||||j���T|||�s�^||f���e|df��|r��yy�w)z*Walk files using a *breadth first* search.rJrN)r�
appendleft�poprr`r@rUrYr\rcrQ)r0rCr8rK�queue�pushrvror`r@rUrY�_check_filer r_rT�_depths                 r2rLzWalker._walk_breadth�s�����t�f�
�������i�i�����
�
���0�0���.�.���.�.���o�o�� ��&����u�H��b�(�z�B�	
-���;�;�-�h�7�%�?�!�C�F�&�r�8�T�:�&��n�,�*�2�x��v�F� ��(�D�I�I�!>�?�"�2�t�,�&��n�,�	
-��D�.� ��s�B*C6�-C6�?#C6�#C6�4C6c#�K�t}|j}|j}|j}|j}|j
}	||�}
|||||��dfg}|j}|r�|d\}
}}t|d�}|�|�|��|
df��|d=no|jrT||
�|
z
dz}|||
|�rK|||
||�r*||
|j�}||||||��|
|ff�n|
|f��n|	||�r|
|f��|r��yy�w)z(Walk files using a *depth first* search.rJN���r)
rr`r@rUrYr\rd�nextrcrQ)r0rCr8rKror`r@rUrYryr �stackrxr_�
iter_files�parentrTrzr?s                   r2rMzWalker._walk_depth�s@�������
�
���0�0���.�.���.�.���o�o�� ��&���5��T�j�9�4�@�
���|�|���+0��9�(�H�j�&��
�D�)�D��|��%� �L���n�$��"�I����)�(�3�e�;�a�?��"�2�x��6�&�r�8�T�6�B� (��4�9�9� =��� %� %�b�%�J� G�!)�4� 0���'��n�,��r�4�(�"�D�.�(�1�s�DD�D)FNrNNNNN)N�r<N�r<)rF�
__module__�__qualname__�__doc__r/�classmethodr#r$r@rDrHrNrUrRrYrXr\r`rjrhrgrTrLrM�
__classcell__)r1s@r2rr2s����H���������:'�x����
����
�4��4��"��"�H
�$�	E�3��"3��&0�,�	�<��	00�d1�$1�*��	7�:�	!!�N�	0)r3rc�R�eZdZdZefd�Zd�Zd�Z		d
d�ZeZ	dd�Z
dd�Z		d
d	�Zy)rBa�A class that binds a `Walker` instance to a `FS` instance.

    You will typically not need to create instances of this class
    explicitly. Filesystems have a `~FS.walk` property which returns a
    `BoundWalker` object.

    Example:
        >>> tmp_fs = fs.tempfs.TempFS()
        >>> tmp_fs.walk
        BoundWalker(TempFS())

    A `BoundWalker` is callable. Calling it is an alias for the
    `~fs.walk.BoundWalker.walk` method.

    c� �||_||_y)z�Create a new walker bound to the given filesystem.

        Arguments:
            fs (FS): A filesystem instance.
            walker_class (type): A `~fs.walk.WalkerBase`
                sub-class. The default uses `~fs.walk.Walker`.

        N)rC�walker_class)r0rCr�s   r2r/zBoundWalker.__init__�s�����(��r3c�8�dj|j�S)NzBoundWalker({!r}))�formatrCrGs r2rHzBoundWalker.__repr__s��"�)�)�$�'�'�2�2r3c�*�|j|i|��}|S)zCreate a walker instance.)r�)r0�args�kwargs�walkers    r2�_make_walkerzBoundWalker._make_walkers ��#��"�"�D�3�F�3���
r3Nc�b�|jdi|��}|j|j||��S)aY
Walk the directory structure of a filesystem.

        Arguments:
            path (str):
            namespaces (list, optional): A list of namespaces to include
                in the resource information, e.g. ``['basic', 'access']``
                (defaults to ``['basic']``).

        Keyword Arguments:
            ignore_errors (bool): If `True`, any errors reading a
                directory will be ignored, otherwise exceptions will be
                raised.
            on_error (callable): If ``ignore_errors`` is `False`, then
                this callable will be invoked with a path and the exception
                object. It should return `True` to ignore the error, or
                `False` to re-raise it.
            search (str): If ``'breadth'`` then the directory will be
                walked *top down*. Set to ``'depth'`` to walk *bottom up*.
            filter (list): If supplied, this parameter should be a list
                of file name patterns, e.g. ``['*.py']``. Files will only be
                returned if the final component matches one of the
                patterns.
            exclude (list, optional): If supplied, this parameter should be
                a list of filename patterns, e.g. ``['~*', '.*']``. Files matching
                any of these patterns will be removed from the walk.
            filter_dirs (list, optional): A list of patterns that will be used
                to match directories paths. The walk will only open directories
                that match at least one of these patterns.
            exclude_dirs (list): A list of patterns that will be used
                to filter out directories from the walk, e.g. ``['*.svn',
                '*.git']``.
            max_depth (int, optional): Maximum directory depth to walk.

        Returns:
            ~collections.Iterator: an iterator of ``(<path>, <dirs>, <files>)``
            named tuples,  where ``<path>`` is an absolute path to a
            directory, and ``<dirs>`` and ``<files>`` are a list of
            `~fs.info.Info` objects for directories and files in ``<path>``.

        Example:
            >>> walker = Walker(filter=['*.py'])
            >>> for path, dirs, files in walker.walk(my_fs, namespaces=['details']):
            ...     print("[{}]".format(path))
            ...     print("{} directories".format(len(dirs)))
            ...     total = sum(info.size for info in files)
            ...     print("{} bytes".format(total))
            [/]
            2 directories
            55 bytes
            ...

        This method invokes `Walker.walk` with bound `FS` object.

        rsr5)r�rjrC�r0r8rKr�r�s     r2rjzBoundWalker.walks3��z#��"�"�,�V�,���{�{�4�7�7��*�{�E�Er3c�`�|jdi|��}|j|j|��S)aAWalk a filesystem, yielding absolute paths to files.

        Arguments:
            path (str): A path to a directory.

        Keyword Arguments:
            ignore_errors (bool): If `True`, any errors reading a
                directory will be ignored, otherwise exceptions will be
                raised.
            on_error (callable): If ``ignore_errors`` is `False`, then
                this callable will be invoked with a path and the exception
                object. It should return `True` to ignore the error, or
                `False` to re-raise it.
            search (str): If ``'breadth'`` then the directory will be
                walked *top down*. Set to ``'depth'`` to walk *bottom up*.
            filter (list): If supplied, this parameter should be a list
                of file name patterns, e.g. ``['*.py']``. Files will only be
                returned if the final component matches one of the
                patterns.
            exclude (list, optional): If supplied, this parameter should be
                a list of filename patterns, e.g. ``['~*', '.*']``. Files matching
                any of these patterns will be removed from the walk.
            filter_dirs (list, optional): A list of patterns that will be used
                to match directories paths. The walk will only open directories
                that match at least one of these patterns.
            exclude_dirs (list): A list of patterns that will be used
                to filter out directories from the walk, e.g. ``['*.svn',
                '*.git']``.
            max_depth (int, optional): Maximum directory depth to walk.

        Returns:
            ~collections.Iterator: An iterator over file paths (absolute
            from the filesystem root).

        This method invokes `Walker.files` with the bound `FS` object.

        rlr5)r�rhrC�r0r8r�r�s    r2rhzBoundWalker.filesTs1��N#��"�"�,�V�,���|�|�D�G�G�$�|�/�/r3c�`�|jdi|��}|j|j|��S)auWalk a filesystem, yielding absolute paths to directories.

        Arguments:
            path (str): A path to a directory.

        Keyword Arguments:
            ignore_errors (bool): If `True`, any errors reading a
                directory will be ignored, otherwise exceptions will be
                raised.
            on_error (callable): If ``ignore_errors`` is `False`, then
                this callable will be invoked with a path and the exception
                object. It should return `True` to ignore the error, or
                `False` to re-raise it.
            search (str): If ``'breadth'`` then the directory will be
                walked *top down*. Set to ``'depth'`` to walk *bottom up*.
            filter_dirs (list, optional): A list of patterns that will be used
                to match directories paths. The walk will only open directories
                that match at least one of these patterns.
            exclude_dirs (list): A list of patterns that will be used
                to filter out directories from the walk, e.g. ``['*.svn',
                '*.git']``.
            max_depth (int, optional): Maximum directory depth to walk.

        Returns:
            ~collections.Iterator: an iterator over directory paths
            (absolute from the filesystem root).

        This method invokes `Walker.dirs` with the bound `FS` object.

        rlr5)r�rgrCr�s    r2rgzBoundWalker.dirs~s1��@#��"�"�,�V�,���{�{�4�7�7��{�.�.r3c�b�|jdi|��}|j|j||��S)aWalk a filesystem, yielding path and `Info` of resources.

        Arguments:
            path (str): A path to a directory.
            namespaces (list, optional): A list of namespaces to include
                in the resource information, e.g. ``['basic', 'access']``
                (defaults to ``['basic']``).

        Keyword Arguments:
            ignore_errors (bool): If `True`, any errors reading a
                directory will be ignored, otherwise exceptions will be
                raised.
            on_error (callable): If ``ignore_errors`` is `False`, then
                this callable will be invoked with a path and the exception
                object. It should return `True` to ignore the error, or
                `False` to re-raise it.
            search (str): If ``'breadth'`` then the directory will be
                walked *top down*. Set to ``'depth'`` to walk *bottom up*.
            filter (list): If supplied, this parameter should be a list
                of file name patterns, e.g. ``['*.py']``. Files will only be
                returned if the final component matches one of the
                patterns.
            exclude (list, optional): If supplied, this parameter should be
                a list of filename patterns, e.g. ``['~*', '.*']``. Files matching
                any of these patterns will be removed from the walk.
            filter_dirs (list, optional): A list of patterns that will be used
                to match directories paths. The walk will only open directories
                that match at least one of these patterns.
            exclude_dirs (list): A list of patterns that will be used
                to filter out directories from the walk, e.g. ``['*.svn',
                '*.git']``.
            max_depth (int, optional): Maximum directory depth to walk.

        Returns:
            ~collections.Iterable: an iterable yielding tuples of
            ``(<absolute path>, <resource info>)``.

        This method invokes `Walker.info` with the bound `FS` object.

        rsr5)r�rTrCr�s     r2rTzBoundWalker.info�s3��^#��"�"�,�V�,���{�{�4�7�7��*�{�E�Er3r�r�)
rFr�r�r�rr/rHr�rj�__call__rhrgrTr5r3r2rBrB�sK��� )/�)�3����>F�@�H�(0�T!/�J��0Fr3rB)0r��
__future__r�typing�collectionsrrr�_reprr�errorsr	r8r
rr�
TYPE_CHECKINGr
rrrrrrrrr�baserrTr�	Exception�bool�OnError�TypeVarrr�objectr�GenericrB�default_walkerrjrh�
walk_files�	walk_inforg�	walk_dirsr5r3r2�<module>r�s����(�
�6�6���,�,�	����������i�(�$�.�/�G��V�^�^�D��%���&�-�.���u)�V�u)�p
gF�&�.�.��$�gF�\�������
�
!�
!�
����	����	r3

Youez - 2016 - github.com/yon3zu
LinuXploit