Sindbad~EG File Manager
�
'ٜg�Q � � � d dl mZ d dlZd dlZd dlmZ d dlmZ ddlm Z ddlm
Z
ddl m Z
dd lmZ ej r d d
lmZ d d lmZ d d �Z d d d
�Z d d�Z d d!d�Zd"d�Z d# d$d�Zd%d�Z G d� d� Z d& d'd�Z G d� d� Z G d� d� Z G d� dej> � Z y)(� )� annotationsN)�partial��update_wrapper� )�ClientDisconnected)�RequestEntityTooLarge)�utils)�host_is_trusted)�WSGIApplication)�WSGIEnvironmentc �" � � t � fd�� � S )a
Marks a function as responder. Decorate a function with it and it
will automatically call the return value as WSGI application.
Example::
@responder
def application(environ, start_response):
return Response('Hello World!')
c � �� �| � | dd � S )N���� )�a�fs ��8/usr/local/lib/python3.12/site-packages/werkzeug/wsgi.py�<lambda>zresponder.<locals>.<lambda> s �� �U�Q��U�A�b�c�F�^� r )r s `r � responderr s �� � �3�Q� 7�7r c � � | d t | |� d�}|sR| j dd� |d< |s;| j dd� |d< |s$| j dd� j d � |d
< t j d i |��S ) aX Recreate the URL for a request from the parts in a WSGI
environment.
The URL is an IRI, not a URI, so it may contain Unicode characters.
Use :func:`~werkzeug.urls.iri_to_uri` to convert it to ASCII.
:param environ: The WSGI environment to get the URL parts from.
:param root_only: Only build the root path, don't include the
remaining path or query string.
:param strip_querystring: Don't include the query string.
:param host_only: Only build the scheme and host.
:param trusted_hosts: A list of trusted host names to validate the
host against.
�wsgi.url_scheme)�scheme�host� SCRIPT_NAME� � root_path� PATH_INFO�path� QUERY_STRING�latin1� query_stringr )�get_host�get�encode�
_sansio_utils�get_current_url)�environ� root_only�strip_querystring� host_only�
trusted_hosts�partss r r( r( s� � �, �+�,���-�0�
�E�
� $�[�[� �� ;��k��� #�K�K� �R� 8�E�&�M�$�(/� � �N�B�(G�(N�(N�x�(X��n�%� � (� (� 1�5� 1�1r c � � | j d� }|�y t | j dd � � }||fS # t t f$ r d }Y ||fS w xY w)N� SERVER_NAME� SERVER_PORT)r% �int� TypeError�
ValueError)r) �name�ports r � _get_serverr7 E se � � �;�;�}� %�D� �|��� �w�{�{�=�$� ?�@��
��:���
�z� "� ��� ��:�� �s �5 �A � A c �h � t j | d | j d� t | � |� S )ar Return the host for the given WSGI environment.
The ``Host`` header is preferred, then ``SERVER_NAME`` if it's not
set. The returned host will only contain the port if it is different
than the standard port for the protocol.
Optionally, verify that the host is trusted using
:func:`host_is_trusted` and raise a
:exc:`~werkzeug.exceptions.SecurityError` if it is not.
:param environ: A WSGI environment dict.
:param trusted_hosts: A list of trusted host names.
:return: Host, with port if necessary.
:raise ~werkzeug.exceptions.SecurityError: If the host is not
trusted.
r � HTTP_HOST)r' r$ r% r7 )r) r- s r r$ r$ V s7 � �( � !� !��!�"�� � �K� ��G� �� � r c �l � t j | j d� | j d� �� S )ad Return the ``Content-Length`` header value as an int. If the header is not given
or the ``Transfer-Encoding`` header is ``chunked``, ``None`` is returned to indicate
a streaming request. If the value is not an integer, or negative, 0 is returned.
:param environ: The WSGI environ to get the content length from.
.. versionadded:: 0.9
�CONTENT_LENGTH�HTTP_TRANSFER_ENCODING)�http_content_length�http_transfer_encoding)r' �get_content_lengthr% )r) s r r? r? r s1 � � � +� +� #�K�K�(8� 9� &�{�{�+C� D� � r c � � t j t j t | d � }t | � }|�|�||kD r
t � �d| v r;|�7t j t j t t
||d�� � S |S |�|rt j � S |S t j t j t t
||� � S )a� Return the WSGI input stream, wrapped so that it may be read safely without going
past the ``Content-Length`` header value or ``max_content_length``.
If ``Content-Length`` exceeds ``max_content_length``, a
:exc:`RequestEntityTooLarge`` ``413 Content Too Large`` error is raised.
If the WSGI server sets ``environ["wsgi.input_terminated"]``, it indicates that the
server handles terminating the stream, so it is safe to read directly. For example,
a server that knows how to handle chunked requests safely would set this.
If ``max_content_length`` is set, it can be enforced on streams if
``wsgi.input_terminated`` is set. Otherwise, an empty stream is returned unless the
user explicitly disables this safe fallback.
If the limit is reached before the underlying stream is exhausted (such as a file
that is too large, or an infinite stream), the remaining contents of the stream
cannot be read safely. Depending on how the server handles this, clients may show a
"connection reset" failure instead of seeing the 413 response.
:param environ: The WSGI environ containing the stream.
:param safe_fallback: Return an empty stream when ``Content-Length`` is not set.
Disabling this allows infinite streams, which can be a denial-of-service risk.
:param max_content_length: The maximum length that content-length or streaming
requests may not exceed.
.. versionchanged:: 2.3.2
``max_content_length`` is only applied to streaming requests if the server sets
``wsgi.input_terminated``.
.. versionchanged:: 2.3
Check ``max_content_length`` and raise an error if it is exceeded.
.. versionadded:: 0.9
z
wsgi.inputzwsgi.input_terminatedT)�is_max) �t�cast�IO�bytesr? r �
LimitedStream�io�BytesIO)r) �
safe_fallback�max_content_length�stream�content_lengths r �get_input_streamrM � s� � �N �V�V�A�D�D��K�� �!6�
7�F�'��0�N��!�&8�&D� � .� .�'�)� )� �'�)� � )� �6�6����U� �]�6�3E�d� S��
� �
�
� � ,�r�z�z�|�8�&�8� �6�6�!�$�$�u�+�}�V�^� D� E�Er c �h � | j dd� j d� }|j d�� S )z�Return ``PATH_INFO`` from the WSGI environment.
:param environ: WSGI environment to get the path from.
.. versionchanged:: 3.0
The ``charset`` and ``errors`` parameters were removed.
.. versionadded:: 0.9
r r r" �replace)�errors)r% r& �decode)r) r s r �
get_path_inforR � s0 � � �+�+�k�2�.�5�5�h�?�D� �;�;�i�;� (�(r c �> � e Zd ZdZ d dd�Zd d�Zd
d�Zd d�Zy) �ClosingIteratoraA The WSGI specification requires that all middlewares and gateways
respect the `close` callback of the iterable returned by the application.
Because it is useful to add another close action to a returned iterable
and adding a custom iterable is a boring task this class can be used for
that::
return ClosingIterator(app(environ, start_response), [cleanup_session,
cleanup_locals])
If there is just one close function it can be passed instead of the list.
A closing iterator is not needed if the application uses response objects
and finishes the processing if the response is started::
try:
return response(environ, start_response)
finally:
cleanup_session()
cleanup_locals()
Nc �( � t |� }t j t j g t f t t |� � | _ |�g }nt |� r|g}n t |� }t |dd � }|r|j d|� || _ y )N�closer )
�iterrB rC �CallablerE r �next�_next�callable�list�getattr�insert�
_callbacks)�self�iterable� callbacks�iterator�iterable_closes r �__init__zClosingIterator.__init__� s~ � � ��>���V�V�A�J�J�r�5�y� 1�7�4��3J�K��
� � ��I�
�i�
�"� �I� �Y��I� ��7�D�9�� � � � �Q�� /�#��r c � � | S �Nr �r` s r �__iter__zClosingIterator.__iter__� � � �� r c �" � | j � S rg )rZ rh s r �__next__zClosingIterator.__next__� s � ��z�z�|�r c �4 � | j D ] } |� � y rg )r_ )r` �callbacks r rV zClosingIterator.close s � � ���H� �J� (r rg )ra �t.Iterable[bytes]rb z@None | (t.Callable[[], None] | t.Iterable[t.Callable[[], None]])�return�None)rp rT �rp rE �rp rq )�__name__�
__module__� __qualname__�__doc__re ri rl rV r r r rT rT � s? � ��2 GK� $�#�$�D�$�
� $�&� �r rT c �< � | j dt � ||� S )a� Wraps a file. This uses the WSGI server's file wrapper if available
or otherwise the generic :class:`FileWrapper`.
.. versionadded:: 0.5
If the file wrapper from the WSGI server is used it's important to not
iterate over it from inside the application but to pass it through
unchanged. If you want to pass out a file wrapper inside a response
object you have to set :attr:`Response.direct_passthrough` to `True`.
More information about file wrappers are available in :pep:`333`.
:param file: a :class:`file`-like object with a :meth:`~file.read` method.
:param buffer_size: number of bytes for one iteration.
zwsgi.file_wrapper)r% � FileWrapper)r) �file� buffer_sizes r � wrap_filer| s$ � �$ 9�7�;�;�*�K� 8� �k� � r c �J � e Zd ZdZd
d d�Zd d�Zd
d�Zdd�Zdd�Zdd�Z dd�Z
y )ry a\ This class can be used to convert a :class:`file`-like object into
an iterable. It yields `buffer_size` blocks until the file is fully
read.
You should not use this class directly but rather use the
:func:`wrap_file` function that uses the WSGI server's file wrapper
support if it's available.
.. versionadded:: 0.5
If you're using this object together with a :class:`Response` you have
to use the `direct_passthrough` mode.
:param file: a :class:`file`-like object with a :meth:`~file.read` method.
:param buffer_size: number of bytes for one iteration.
c � � || _ || _ y rg )rz r{ )r` rz r{ s r re zFileWrapper.__init__0 s � ��� �&��r c �f � t | j d� r| j j � y y �NrV )�hasattrrz rV rh s r rV zFileWrapper.close4 s# � � �4�9�9�g� &� �I�I�O�O� � 'r c � � t | j d� r| j j � S t | j d� ryy)N�seekable�seekTF)r� rz r� rh s r r� zFileWrapper.seekable8 s7 � � �4�9�9�j� )��9�9�%�%�'� '� �4�9�9�f� %��r c �d � t | j d� r | j j |� y y )Nr� )r� rz r� )r` �argss r r� zFileWrapper.seek? s' � � �4�9�9�f� %� �D�I�I�N�N�D� !� &r c �d � t | j d� r| j j � S y )N�tell)r� rz r� rh s r r� zFileWrapper.tellC s$ � � �4�9�9�f� %��9�9�>�>�#� #�r c � � | S rg r rh s r ri zFileWrapper.__iter__H rj r c �h � | j j | j � }|r|S t � �rg )rz �readr{ �
StopIteration)r` �datas r rl zFileWrapper.__next__K s* � ��y�y�~�~�d� .� .�/�� ��K��o� r N�i )rz � t.IO[bytes]r{ r2 rp rq rs �rp �bool)r� zt.Anyrp rq )rp �
int | None)rp ry rr ) rt ru rv rw re rV r� r� r� ri rl r r r ry ry s* � ��"'� ��"��
� r ry c �X � e Zd ZdZ d
d d�Zd d�Zd
d�Zdd�Zd
d�Zd
d�Z dd �Z
y)�
_RangeWrapperas This class can be used to convert an iterable object into
an iterable that will only yield a piece of the underlying content.
It yields blocks until the underlying stream range is fully read.
The yielded blocks will have a size that can't exceed the original
iterator defined block size, but that can be smaller.
If you're using this object together with a :class:`Response` you have
to use the `direct_passthrough` mode.
:param iterable: an iterable object with a :meth:`__next__` method.
:param start_byte: byte from which read will start.
:param byte_range: how many bytes to read.
Nc �� � t |� | _ || _ || _ d | _ |�
||z | _ d| _ t
|d� xr |j � | _ d| _ y )Nr r� F) rW ra �
byte_range�
start_byte�end_byte� read_lengthr� r� � end_reached)r` ra r� r� s r re z_RangeWrapper.__init__c sb � � �X���
�$���$��� ��
� � !� &�� 3�D�M� ��� ��*�5�M�(�:K�:K�:M��
� ��r c � � | S rg r rh s r ri z_RangeWrapper.__iter__u rj r c � � t | j � }| xj t |� z
c_ |S # t $ r d| _ � w xY w�NT)rY ra r� �lenr� r� �r` �chunks r � _next_chunkz_RangeWrapper._next_chunkx sI � � ��� � �'�E� � � ��E�
� *� ��L�� � � #�D� � � �s �47 �A c � � d }| j rT| j j | j � | j j � | _ | j
}||fS | j
| j k r*| j
� }| j
| j k r�*|� || j | j
z
d }| j }||fS rg )r� ra r� r� r� r� r� �r` r� �contextual_read_lengths r �_first_iterationz _RangeWrapper._first_iteration� s� � ��� �=�=� �M�M� � �t��� /� #�}�}� 1� 1� 3�D� �%)�%5�%5� "� �,�,�,� �"�"�d�o�o�5� �(�(�*�� �"�"�d�o�o�5�� � �d�o�o��0@�0@� @� B�C��%)�_�_� "��,�,�,r c �2 � | j r
t � �d }| j }| j dk( r| j � \ }}|�| j � }| j
�2| j | j
k\ rd| _ |d | j
|z
S |S )Nr T)r� r� r� r� r� r� r� s r rZ z_RangeWrapper._next� s� � � � � � �/� !���!%�!1�!1� � � � �q� �,0�,A�,A�,C� )�E�)� �=��$�$�&�E� �=�=� $��)9�)9�T�]�]�)J� #�D� ��A�4�=�=�+A�A�B� B�� r c �L � | j � }|r|S d| _ t � �r� )rZ r� r� r� s r rl z_RangeWrapper.__next__� s% � ��
�
� �� ��L� ����o� r c �f � t | j d� r| j j � y y r� )r� ra rV rh s r rV z_RangeWrapper.close� s% � � �4�=�=�'� *� �M�M� � � !� +r )r N)ra z t.Iterable[bytes] | t.IO[bytes]r� r2 r� r� )rp r� rr )rp ztuple[bytes | None, int]rs ) rt ru rv rw re ri r� r� rZ rl rV r r r r� r� R sN � � �" �!%� !�1�!� �!� � !�$�� -� � �"r r� c �f � e Zd ZdZd d
d�Zedd�� Zdd�Zddd�Zdd�Z dd�Z
dd �Z dd
�Z dd �Z
y)rF a: Wrap a stream so that it doesn't read more than a given limit. This is used to
limit ``wsgi.input`` to the ``Content-Length`` header value or
:attr:`.Request.max_content_length`.
When attempting to read after the limit has been reached, :meth:`on_exhausted` is
called. When the limit is a maximum, this raises :exc:`.RequestEntityTooLarge`.
If reading from the stream returns zero bytes or raises an error,
:meth:`on_disconnect` is called, which raises :exc:`.ClientDisconnected`. When the
limit is a maximum and zero bytes were read, no error is raised, since it may be the
end of the stream.
If the limit is reached before the underlying stream is exhausted (such as a file
that is too large, or an infinite stream), the remaining contents of the stream
cannot be read safely. Depending on how the server handles this, clients may show a
"connection reset" failure instead of seeing the 413 response.
:param stream: The stream to read from. Must be a readable binary IO object.
:param limit: The limit in bytes to not read past. Should be either the
``Content-Length`` header value or ``request.max_content_length``.
:param is_max: Whether the given ``limit`` is ``request.max_content_length`` instead
of the ``Content-Length`` header value. This changes how exhausted and
disconnect events are handled.
.. versionchanged:: 2.3
Handle ``max_content_length`` differently than ``Content-Length``.
.. versionchanged:: 2.3
Implements ``io.RawIOBase`` rather than ``io.IOBase``.
c �< � || _ d| _ || _ || _ y )Nr )�_stream�_pos�limit�
_limit_is_max)r` rK r� rA s r re zLimitedStream.__init__� s � � �� ��� ���
� #��r c �4 � | j | j k\ S )z:Whether the current stream position has reached the limit.)r� r� rh s r � is_exhaustedzLimitedStream.is_exhausted� s � � �y�y�D�J�J�&�&r c �0 � | j r
t � �y)a� Called when attempting to read after the limit has been reached.
The default behavior is to do nothing, unless the limit is a maximum, in which
case it raises :exc:`.RequestEntityTooLarge`.
.. versionchanged:: 2.3
Raises ``RequestEntityTooLarge`` if the limit is a maximum.
.. versionchanged:: 2.3
Any return value is ignored.
N)r� r rh s r � on_exhaustedzLimitedStream.on_exhausted� s � � � � �'�)� )� r Nc �4 � | j r|�
t � �y)a Called when an attempted read receives zero bytes before the limit was
reached. This indicates that the client disconnected before sending the full
request body.
The default behavior is to raise :exc:`.ClientDisconnected`, unless the limit is
a maximum and no error was raised.
.. versionchanged:: 2.3
Added the ``error`` parameter. Do nothing if the limit is a maximum and no
error was raised.
.. versionchanged:: 2.3
Any return value is ignored.
N)r� r )r` �errors r �
on_disconnectzLimitedStream.on_disconnect� s � � �!�!�U�%6�$�&� &� &7r c �< � | j s| j � S y)a> Exhaust the stream by reading until the limit is reached or the client
disconnects, returning the remaining data.
.. versionchanged:: 2.3
Return the remaining data.
.. versionchanged:: 2.2.3
Handle case where wrapped stream returns fewer bytes than requested.
r )r� �readallrh s r �exhaustzLimitedStream.exhaust� s � � � � ��<�<�>� !�r c � � t |� }| j | j z
}|dk r| j � yt | j
d� rQ||k r | j
j
|� }net |� } | j
j
|� }|r<||d | n6 | j
j t ||� � }t |� }||d | |s| j � y| xj |z
c_ |S # t t f$ r }| j |�� Y d }~yd }~ww xY w# t t f$ r }| j |�� Y d }~yd }~ww xY w# t t f$ r }| j |�� Y d }~yd }~ww xY w)Nr �readinto)r� )
r� r� r� r� r� r� r� �OSErrorr4 r� � bytearrayr� �min)r` �b�size� remaining�out_size�e�temp_br� s r r� zLimitedStream.readinto sr � ��1�v���J�J����*� � ��>� � � � �� �4�<�<�� ,��y� � �+/�<�<�+@�+@��+C�H� #�9�-�� � #�|�|� 4� 4�V� <�H�
�#)�A�i�x�L�
��|�|�(�(��T�9�)=�>��
�4�y�H� �A�i�x�L�� � � � �� � � �X� � ����A ��,� ��&�&�Q�&�/� �� �� ��,� ��&�&�Q�&�/� �� �� �Z�(�
��"�"��"�+���
�sH �D �?D0 �#%E �D-�D(�(D-�0E�?E�E� F �-F�F c � � | j r| j � yt � }| j s=| j d� }|s t |� S |j |� | j s�=t |� S )Nr i )r� r� r� r� �extendrE )r` �outr� s r r� zLimitedStream.readall8 ss � � � � � � � � ���k�� �#�#��9�9�Y�'�D� �� �S�z��
�J�J�t� � �#�#� �S�z�r c � � | j S )zKReturn the current stream position.
.. versionadded:: 0.9
)r� rh s r r� zLimitedStream.tellK s � �
�y�y�r c � � yr� r rh s r �readablezLimitedStream.readableR s � �r )F)rK r� r� r2 rA r� rp rq r� rs rg )r� zException | Nonerp rq rr )r� r� rp r� )rp r2 )rt ru rv rw re �propertyr� r� r� r� r� r� r� r� r r r rF rF � sD � � �>$� �'� �'�
*� '�,
� .�`�&�r rF )r z t.Callable[..., WSGIApplication]rp r )FFFN) r) r
r* r� r+ r� r, r� r- �t.Iterable[str] | Nonerp �str)r) r
rp z tuple[str, int | None] | Nonerg )r) r
r- r� rp r� )r) r
rp r� )TN)r) r
rI r� rJ r� rp r� )r) r
rp r� r� )r) r
rz r� r{ r2 rp ro )!�
__future__r rG �typingrB � functoolsr r �
exceptionsr r �sansior
r' � sansio.utilsr �
TYPE_CHECKING�_typeshed.wsgir r
r r( r7 r$ r? rM rR rT r| ry r� � RawIOBaserF r r r �<module>r� s^ �� "� � � � $� *� -� *� )��?�?�.�.�
8� � #��,0� #2�
�#2��#2� �#2� � #2�
*� #2� �
#2�L�
��"��$ GK��
��-C����8 �" �%)�AF�
�AF��AF� #�AF� � AF�H )� 1� 1�j EI��
��$/��>A����.1 � 1 �hT"� T"�nj�B�L�L� jr
Sindbad File Manager Version 1.0, Coded By Sindbad EG ~ The Terrorists