handlers.py 0000644 00000052245 15154351672 0006737 0 ustar 00 """Base classes for server/gateway implementations"""
from .util import FileWrapper, guess_scheme, is_hop_by_hop
from .headers import Headers
import sys, os, time
__all__ = [
'BaseHandler', 'SimpleHandler', 'BaseCGIHandler', 'CGIHandler',
'IISCGIHandler', 'read_environ'
]
# Weekday and month names for HTTP date/time formatting; always English!
_weekdayname = ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"]
_monthname = [None, # Dummy so we can use 1-based month numbers
"Jan", "Feb", "Mar", "Apr", "May", "Jun",
"Jul", "Aug", "Sep", "Oct", "Nov", "Dec"]
def format_date_time(timestamp):
year, month, day, hh, mm, ss, wd, y, z = time.gmtime(timestamp)
return "%s, %02d %3s %4d %02d:%02d:%02d GMT" % (
_weekdayname[wd], day, _monthname[month], year, hh, mm, ss
)
_is_request = {
'SCRIPT_NAME', 'PATH_INFO', 'QUERY_STRING', 'REQUEST_METHOD', 'AUTH_TYPE',
'CONTENT_TYPE', 'CONTENT_LENGTH', 'HTTPS', 'REMOTE_USER', 'REMOTE_IDENT',
}.__contains__
def _needs_transcode(k):
return _is_request(k) or k.startswith('HTTP_') or k.startswith('SSL_') \
or (k.startswith('REDIRECT_') and _needs_transcode(k[9:]))
def read_environ():
"""Read environment, fixing HTTP variables"""
enc = sys.getfilesystemencoding()
esc = 'surrogateescape'
try:
''.encode('utf-8', esc)
except LookupError:
esc = 'replace'
environ = {}
# Take the basic environment from native-unicode os.environ. Attempt to
# fix up the variables that come from the HTTP request to compensate for
# the bytes->unicode decoding step that will already have taken place.
for k, v in os.environ.items():
if _needs_transcode(k):
# On win32, the os.environ is natively Unicode. Different servers
# decode the request bytes using different encodings.
if sys.platform == 'win32':
software = os.environ.get('SERVER_SOFTWARE', '').lower()
# On IIS, the HTTP request will be decoded as UTF-8 as long
# as the input is a valid UTF-8 sequence. Otherwise it is
# decoded using the system code page (mbcs), with no way to
# detect this has happened. Because UTF-8 is the more likely
# encoding, and mbcs is inherently unreliable (an mbcs string
# that happens to be valid UTF-8 will not be decoded as mbcs)
# always recreate the original bytes as UTF-8.
if software.startswith('microsoft-iis/'):
v = v.encode('utf-8').decode('iso-8859-1')
# Apache mod_cgi writes bytes-as-unicode (as if ISO-8859-1) direct
# to the Unicode environ. No modification needed.
elif software.startswith('apache/'):
pass
# Python 3's http.server.CGIHTTPRequestHandler decodes
# using the urllib.unquote default of UTF-8, amongst other
# issues.
elif (
software.startswith('simplehttp/')
and 'python/3' in software
):
v = v.encode('utf-8').decode('iso-8859-1')
# For other servers, guess that they have written bytes to
# the environ using stdio byte-oriented interfaces, ending up
# with the system code page.
else:
v = v.encode(enc, 'replace').decode('iso-8859-1')
# Recover bytes from unicode environ, using surrogate escapes
# where available (Python 3.1+).
else:
v = v.encode(enc, esc).decode('iso-8859-1')
environ[k] = v
return environ
class BaseHandler:
"""Manage the invocation of a WSGI application"""
# Configuration parameters; can override per-subclass or per-instance
wsgi_version = (1,0)
wsgi_multithread = True
wsgi_multiprocess = True
wsgi_run_once = False
origin_server = True # We are transmitting direct to client
http_version = "1.0" # Version that should be used for response
server_software = None # String name of server software, if any
# os_environ is used to supply configuration from the OS environment:
# by default it's a copy of 'os.environ' as of import time, but you can
# override this in e.g. your __init__ method.
os_environ= read_environ()
# Collaborator classes
wsgi_file_wrapper = FileWrapper # set to None to disable
headers_class = Headers # must be a Headers-like class
# Error handling (also per-subclass or per-instance)
traceback_limit = None # Print entire traceback to self.get_stderr()
error_status = "500 Internal Server Error"
error_headers = [('Content-Type','text/plain')]
error_body = b"A server error occurred. Please contact the administrator."
# State variables (don't mess with these)
status = result = None
headers_sent = False
headers = None
bytes_sent = 0
def run(self, application):
"""Invoke the application"""
# Note to self: don't move the close()! Asynchronous servers shouldn't
# call close() from finish_response(), so if you close() anywhere but
# the double-error branch here, you'll break asynchronous servers by
# prematurely closing. Async servers must return from 'run()' without
# closing if there might still be output to iterate over.
try:
self.setup_environ()
self.result = application(self.environ, self.start_response)
self.finish_response()
except (ConnectionAbortedError, BrokenPipeError, ConnectionResetError):
# We expect the client to close the connection abruptly from time
# to time.
return
except:
try:
self.handle_error()
except:
# If we get an error handling an error, just give up already!
self.close()
raise # ...and let the actual server figure it out.
def setup_environ(self):
"""Set up the environment for one request"""
env = self.environ = self.os_environ.copy()
self.add_cgi_vars()
env['wsgi.input'] = self.get_stdin()
env['wsgi.errors'] = self.get_stderr()
env['wsgi.version'] = self.wsgi_version
env['wsgi.run_once'] = self.wsgi_run_once
env['wsgi.url_scheme'] = self.get_scheme()
env['wsgi.multithread'] = self.wsgi_multithread
env['wsgi.multiprocess'] = self.wsgi_multiprocess
if self.wsgi_file_wrapper is not None:
env['wsgi.file_wrapper'] = self.wsgi_file_wrapper
if self.origin_server and self.server_software:
env.setdefault('SERVER_SOFTWARE',self.server_software)
def finish_response(self):
"""Send any iterable data, then close self and the iterable
Subclasses intended for use in asynchronous servers will
want to redefine this method, such that it sets up callbacks
in the event loop to iterate over the data, and to call
'self.close()' once the response is finished.
"""
try:
if not self.result_is_file() or not self.sendfile():
for data in self.result:
self.write(data)
self.finish_content()
except:
# Call close() on the iterable returned by the WSGI application
# in case of an exception.
if hasattr(self.result, 'close'):
self.result.close()
raise
else:
# We only call close() when no exception is raised, because it
# will set status, result, headers, and environ fields to None.
# See bpo-29183 for more details.
self.close()
def get_scheme(self):
"""Return the URL scheme being used"""
return guess_scheme(self.environ)
def set_content_length(self):
"""Compute Content-Length or switch to chunked encoding if possible"""
try:
blocks = len(self.result)
except (TypeError,AttributeError,NotImplementedError):
pass
else:
if blocks==1:
self.headers['Content-Length'] = str(self.bytes_sent)
return
# XXX Try for chunked encoding if origin server and client is 1.1
def cleanup_headers(self):
"""Make any necessary header changes or defaults
Subclasses can extend this to add other defaults.
"""
if 'Content-Length' not in self.headers:
self.set_content_length()
def start_response(self, status, headers,exc_info=None):
"""'start_response()' callable as specified by PEP 3333"""
if exc_info:
try:
if self.headers_sent:
# Re-raise original exception if headers sent
raise exc_info[0](exc_info[1]).with_traceback(exc_info[2])
finally:
exc_info = None # avoid dangling circular ref
elif self.headers is not None:
raise AssertionError("Headers already set!")
self.status = status
self.headers = self.headers_class(headers)
status = self._convert_string_type(status, "Status")
assert len(status)>=4,"Status must be at least 4 characters"
assert status[:3].isdigit(), "Status message must begin w/3-digit code"
assert status[3]==" ", "Status message must have a space after code"
if __debug__:
for name, val in headers:
name = self._convert_string_type(name, "Header name")
val = self._convert_string_type(val, "Header value")
assert not is_hop_by_hop(name),\
f"Hop-by-hop header, '{name}: {val}', not allowed"
return self.write
def _convert_string_type(self, value, title):
"""Convert/check value type."""
if type(value) is str:
return value
raise AssertionError(
"{0} must be of type str (got {1})".format(title, repr(value))
)
def send_preamble(self):
"""Transmit version/status/date/server, via self._write()"""
if self.origin_server:
if self.client_is_modern():
self._write(('HTTP/%s %s\r\n' % (self.http_version,self.status)).encode('iso-8859-1'))
if 'Date' not in self.headers:
self._write(
('Date: %s\r\n' % format_date_time(time.time())).encode('iso-8859-1')
)
if self.server_software and 'Server' not in self.headers:
self._write(('Server: %s\r\n' % self.server_software).encode('iso-8859-1'))
else:
self._write(('Status: %s\r\n' % self.status).encode('iso-8859-1'))
def write(self, data):
"""'write()' callable as specified by PEP 3333"""
assert type(data) is bytes, \
"write() argument must be a bytes instance"
if not self.status:
raise AssertionError("write() before start_response()")
elif not self.headers_sent:
# Before the first output, send the stored headers
self.bytes_sent = len(data) # make sure we know content-length
self.send_headers()
else:
self.bytes_sent += len(data)
# XXX check Content-Length and truncate if too many bytes written?
self._write(data)
self._flush()
def sendfile(self):
"""Platform-specific file transmission
Override this method in subclasses to support platform-specific
file transmission. It is only called if the application's
return iterable ('self.result') is an instance of
'self.wsgi_file_wrapper'.
This method should return a true value if it was able to actually
transmit the wrapped file-like object using a platform-specific
approach. It should return a false value if normal iteration
should be used instead. An exception can be raised to indicate
that transmission was attempted, but failed.
NOTE: this method should call 'self.send_headers()' if
'self.headers_sent' is false and it is going to attempt direct
transmission of the file.
"""
return False # No platform-specific transmission by default
def finish_content(self):
"""Ensure headers and content have both been sent"""
if not self.headers_sent:
# Only zero Content-Length if not set by the application (so
# that HEAD requests can be satisfied properly, see #3839)
self.headers.setdefault('Content-Length', "0")
self.send_headers()
else:
pass # XXX check if content-length was too short?
def close(self):
"""Close the iterable (if needed) and reset all instance vars
Subclasses may want to also drop the client connection.
"""
try:
if hasattr(self.result,'close'):
self.result.close()
finally:
self.result = self.headers = self.status = self.environ = None
self.bytes_sent = 0; self.headers_sent = False
def send_headers(self):
"""Transmit headers to the client, via self._write()"""
self.cleanup_headers()
self.headers_sent = True
if not self.origin_server or self.client_is_modern():
self.send_preamble()
self._write(bytes(self.headers))
def result_is_file(self):
"""True if 'self.result' is an instance of 'self.wsgi_file_wrapper'"""
wrapper = self.wsgi_file_wrapper
return wrapper is not None and isinstance(self.result,wrapper)
def client_is_modern(self):
"""True if client can accept status and headers"""
return self.environ['SERVER_PROTOCOL'].upper() != 'HTTP/0.9'
def log_exception(self,exc_info):
"""Log the 'exc_info' tuple in the server log
Subclasses may override to retarget the output or change its format.
"""
try:
from traceback import print_exception
stderr = self.get_stderr()
print_exception(
exc_info[0], exc_info[1], exc_info[2],
self.traceback_limit, stderr
)
stderr.flush()
finally:
exc_info = None
def handle_error(self):
"""Log current error, and send error output to client if possible"""
self.log_exception(sys.exc_info())
if not self.headers_sent:
self.result = self.error_output(self.environ, self.start_response)
self.finish_response()
# XXX else: attempt advanced recovery techniques for HTML or text?
def error_output(self, environ, start_response):
"""WSGI mini-app to create error output
By default, this just uses the 'error_status', 'error_headers',
and 'error_body' attributes to generate an output page. It can
be overridden in a subclass to dynamically generate diagnostics,
choose an appropriate message for the user's preferred language, etc.
Note, however, that it's not recommended from a security perspective to
spit out diagnostics to any old user; ideally, you should have to do
something special to enable diagnostic output, which is why we don't
include any here!
"""
start_response(self.error_status,self.error_headers[:],sys.exc_info())
return [self.error_body]
# Pure abstract methods; *must* be overridden in subclasses
def _write(self,data):
"""Override in subclass to buffer data for send to client
It's okay if this method actually transmits the data; BaseHandler
just separates write and flush operations for greater efficiency
when the underlying system actually has such a distinction.
"""
raise NotImplementedError
def _flush(self):
"""Override in subclass to force sending of recent '_write()' calls
It's okay if this method is a no-op (i.e., if '_write()' actually
sends the data.
"""
raise NotImplementedError
def get_stdin(self):
"""Override in subclass to return suitable 'wsgi.input'"""
raise NotImplementedError
def get_stderr(self):
"""Override in subclass to return suitable 'wsgi.errors'"""
raise NotImplementedError
def add_cgi_vars(self):
"""Override in subclass to insert CGI variables in 'self.environ'"""
raise NotImplementedError
class SimpleHandler(BaseHandler):
"""Handler that's just initialized with streams, environment, etc.
This handler subclass is intended for synchronous HTTP/1.0 origin servers,
and handles sending the entire response output, given the correct inputs.
Usage::
handler = SimpleHandler(
inp,out,err,env, multithread=False, multiprocess=True
)
handler.run(app)"""
def __init__(self,stdin,stdout,stderr,environ,
multithread=True, multiprocess=False
):
self.stdin = stdin
self.stdout = stdout
self.stderr = stderr
self.base_env = environ
self.wsgi_multithread = multithread
self.wsgi_multiprocess = multiprocess
def get_stdin(self):
return self.stdin
def get_stderr(self):
return self.stderr
def add_cgi_vars(self):
self.environ.update(self.base_env)
def _write(self,data):
result = self.stdout.write(data)
if result is None or result == len(data):
return
from warnings import warn
warn("SimpleHandler.stdout.write() should not do partial writes",
DeprecationWarning)
while True:
data = data[result:]
if not data:
break
result = self.stdout.write(data)
def _flush(self):
self.stdout.flush()
self._flush = self.stdout.flush
class BaseCGIHandler(SimpleHandler):
"""CGI-like systems using input/output/error streams and environ mapping
Usage::
handler = BaseCGIHandler(inp,out,err,env)
handler.run(app)
This handler class is useful for gateway protocols like ReadyExec and
FastCGI, that have usable input/output/error streams and an environment
mapping. It's also the base class for CGIHandler, which just uses
sys.stdin, os.environ, and so on.
The constructor also takes keyword arguments 'multithread' and
'multiprocess' (defaulting to 'True' and 'False' respectively) to control
the configuration sent to the application. It sets 'origin_server' to
False (to enable CGI-like output), and assumes that 'wsgi.run_once' is
False.
"""
origin_server = False
class CGIHandler(BaseCGIHandler):
"""CGI-based invocation via sys.stdin/stdout/stderr and os.environ
Usage::
CGIHandler().run(app)
The difference between this class and BaseCGIHandler is that it always
uses 'wsgi.run_once' of 'True', 'wsgi.multithread' of 'False', and
'wsgi.multiprocess' of 'True'. It does not take any initialization
parameters, but always uses 'sys.stdin', 'os.environ', and friends.
If you need to override any of these parameters, use BaseCGIHandler
instead.
"""
wsgi_run_once = True
# Do not allow os.environ to leak between requests in Google App Engine
# and other multi-run CGI use cases. This is not easily testable.
# See http://bugs.python.org/issue7250
os_environ = {}
def __init__(self):
BaseCGIHandler.__init__(
self, sys.stdin.buffer, sys.stdout.buffer, sys.stderr,
read_environ(), multithread=False, multiprocess=True
)
class IISCGIHandler(BaseCGIHandler):
"""CGI-based invocation with workaround for IIS path bug
This handler should be used in preference to CGIHandler when deploying on
Microsoft IIS without having set the config allowPathInfo option (IIS>=7)
or metabase allowPathInfoForScriptMappings (IIS<7).
"""
wsgi_run_once = True
os_environ = {}
# By default, IIS gives a PATH_INFO that duplicates the SCRIPT_NAME at
# the front, causing problems for WSGI applications that wish to implement
# routing. This handler strips any such duplicated path.
# IIS can be configured to pass the correct PATH_INFO, but this causes
# another bug where PATH_TRANSLATED is wrong. Luckily this variable is
# rarely used and is not guaranteed by WSGI. On IIS<7, though, the
# setting can only be made on a vhost level, affecting all other script
# mappings, many of which break when exposed to the PATH_TRANSLATED bug.
# For this reason IIS<7 is almost never deployed with the fix. (Even IIS7
# rarely uses it because there is still no UI for it.)
# There is no way for CGI code to tell whether the option was set, so a
# separate handler class is provided.
def __init__(self):
environ= read_environ()
path = environ.get('PATH_INFO', '')
script = environ.get('SCRIPT_NAME', '')
if (path+'/').startswith(script+'/'):
environ['PATH_INFO'] = path[len(script):]
BaseCGIHandler.__init__(
self, sys.stdin.buffer, sys.stdout.buffer, sys.stderr,
environ, multithread=False, multiprocess=True
)
simple_server.py 0000644 00000012063 15154351672 0010010 0 ustar 00 """BaseHTTPServer that implements the Python WSGI protocol (PEP 3333)
This is both an example of how WSGI can be implemented, and a basis for running
simple web applications on a local machine, such as might be done when testing
or debugging an application. It has not been reviewed for security issues,
however, and we strongly recommend that you use a "real" web server for
production use.
For example usage, see the 'if __name__=="__main__"' block at the end of the
module. See also the BaseHTTPServer module docs for other API information.
"""
from http.server import BaseHTTPRequestHandler, HTTPServer
import sys
import urllib.parse
from wsgiref.handlers import SimpleHandler
from platform import python_implementation
__version__ = "0.2"
__all__ = ['WSGIServer', 'WSGIRequestHandler', 'demo_app', 'make_server']
server_version = "WSGIServer/" + __version__
sys_version = python_implementation() + "/" + sys.version.split()[0]
software_version = server_version + ' ' + sys_version
class ServerHandler(SimpleHandler):
server_software = software_version
def close(self):
try:
self.request_handler.log_request(
self.status.split(' ',1)[0], self.bytes_sent
)
finally:
SimpleHandler.close(self)
class WSGIServer(HTTPServer):
"""BaseHTTPServer that implements the Python WSGI protocol"""
application = None
def server_bind(self):
"""Override server_bind to store the server name."""
HTTPServer.server_bind(self)
self.setup_environ()
def setup_environ(self):
# Set up base environment
env = self.base_environ = {}
env['SERVER_NAME'] = self.server_name
env['GATEWAY_INTERFACE'] = 'CGI/1.1'
env['SERVER_PORT'] = str(self.server_port)
env['REMOTE_HOST']=''
env['CONTENT_LENGTH']=''
env['SCRIPT_NAME'] = ''
def get_app(self):
return self.application
def set_app(self,application):
self.application = application
class WSGIRequestHandler(BaseHTTPRequestHandler):
server_version = "WSGIServer/" + __version__
def get_environ(self):
env = self.server.base_environ.copy()
env['SERVER_PROTOCOL'] = self.request_version
env['SERVER_SOFTWARE'] = self.server_version
env['REQUEST_METHOD'] = self.command
if '?' in self.path:
path,query = self.path.split('?',1)
else:
path,query = self.path,''
env['PATH_INFO'] = urllib.parse.unquote(path, 'iso-8859-1')
env['QUERY_STRING'] = query
host = self.address_string()
if host != self.client_address[0]:
env['REMOTE_HOST'] = host
env['REMOTE_ADDR'] = self.client_address[0]
if self.headers.get('content-type') is None:
env['CONTENT_TYPE'] = self.headers.get_content_type()
else:
env['CONTENT_TYPE'] = self.headers['content-type']
length = self.headers.get('content-length')
if length:
env['CONTENT_LENGTH'] = length
for k, v in self.headers.items():
k=k.replace('-','_').upper(); v=v.strip()
if k in env:
continue # skip content length, type,etc.
if 'HTTP_'+k in env:
env['HTTP_'+k] += ','+v # comma-separate multiple headers
else:
env['HTTP_'+k] = v
return env
def get_stderr(self):
return sys.stderr
def handle(self):
"""Handle a single HTTP request"""
self.raw_requestline = self.rfile.readline(65537)
if len(self.raw_requestline) > 65536:
self.requestline = ''
self.request_version = ''
self.command = ''
self.send_error(414)
return
if not self.parse_request(): # An error code has been sent, just exit
return
handler = ServerHandler(
self.rfile, self.wfile, self.get_stderr(), self.get_environ(),
multithread=False,
)
handler.request_handler = self # backpointer for logging
handler.run(self.server.get_app())
def demo_app(environ,start_response):
from io import StringIO
stdout = StringIO()
print("Hello world!", file=stdout)
print(file=stdout)
h = sorted(environ.items())
for k,v in h:
print(k,'=',repr(v), file=stdout)
start_response("200 OK", [('Content-Type','text/plain; charset=utf-8')])
return [stdout.getvalue().encode("utf-8")]
def make_server(
host, port, app, server_class=WSGIServer, handler_class=WSGIRequestHandler
):
"""Create a new WSGI server listening on `host` and `port` for `app`"""
server = server_class((host, port), handler_class)
server.set_app(app)
return server
if __name__ == '__main__':
with make_server('', 8000, demo_app) as httpd:
sa = httpd.socket.getsockname()
print("Serving HTTP on", sa[0], "port", sa[1], "...")
import webbrowser
webbrowser.open('http://localhost:8000/xyz?abc')
httpd.handle_request() # serve one request, then exit
__pycache__/validate.cpython-310.opt-2.pyc 0000644 00000025351 15154351672 0014225 0 ustar 00 o
���h�: � @ s� d gZ ddlZddlZddlZe�d�Ze�d�ZG dd� de�Zdd� Z d d
� Z
d d � Z G d d
� d
�Z G dd� d�Z
G dd� d�ZG dd� d�ZG dd� d�Zdd� Zdd� Zdd� Zd d � Zd d � Zd d!� Zd"d#� Zd$d%� ZdS )&� validator� Nz^[a-zA-Z][a-zA-Z0-9\-_]*$z [\000-\037]c @ s e Zd ZdS )� WSGIWarningN)�__name__�
__module__� __qualname__� r r �7/opt/alt/python310/lib64/python3.10/wsgiref/validate.pyr y s r c G s | st |� �d S �N)�AssertionError)Zcond�argsr r r �assert_~ s �r c C s$ t | �tu r| S td�|t| ����)Nz!{0} must be of type str (got {1}))�type�strr
�format�repr)�value�titler r r �check_string_type� s
�r c s � fdd�}|S )Nc s� t t| �dkd� t | d� | \}� t|� g �� �fdd�}t|d �|d< t|d �|d< �||�}t |d uo=|dkd � t|� t|��S )
N� zTwo arguments required� No keyword arguments allowedc s� t t| �dkp t| �dkd| f � t | d� | d }| d }t| �dkr+| d }nd }t|� t|� t||� t|� ��d � t� | � �S )Nr � z Invalid number of arguments: %sr r � )r �len� check_status�
check_headers�check_content_type�check_exc_info�append� WriteWrapper)r �kw�status�headers�exc_info�Zstart_responseZstart_response_startedr r �start_response_wrapper� s �
z;validator.<locals>.lint_app.<locals>.start_response_wrapper�
wsgi.input� wsgi.errorsFz>The application must return an iterator, if only an empty list)r r �
check_environ� InputWrapper� ErrorWrapper�check_iterator�IteratorWrapper)r r �environr$ �iterator�� applicationr# r �lint_app� s
�
zvalidator.<locals>.lint_appr )r/ r0 r r. r r � s
)c @ s< e Zd Zdd� Zdd� Zdd� Zdd� Zd d
� Zd d � Zd
S )r( c C �
|| _ d S r )�input)�self�
wsgi_inputr r r �__init__� �
zInputWrapper.__init__c G s0 t t|�dk� | jj|� }t t|�tu � |S �Nr )r r r2 �readr
�bytes�r3 r �vr r r r8 � � zInputWrapper.readc G s0 t t|�dk� | jj|� }t t|�tu � |S r7 )r r r2 �readliner
r9 r: r r r r= � r< zInputWrapper.readlinec G sJ t t|�dk� | jj|� }t t|�tu � |D ]
}t t|�tu � q|S r7 )r r r2 � readlinesr
�listr9 )r3 r �lines�liner r r r> � s zInputWrapper.readlinesc c s � | � � }|s
d S |V qr )r= )r3 rA r r r �__iter__� s ��zInputWrapper.__iter__c C � t dd� d S )Nr z input.close() must not be called�r �r3 r r r �close� � zInputWrapper.closeN) r r r r5 r8 r= r> rB rF r r r r r( � s r( c @ �4 e Zd Zdd� Zdd� Zdd� Zdd� Zd d
� Zd S ) r) c C r1 r )�errors)r3 � wsgi_errorsr r r r5 � r6 zErrorWrapper.__init__c C s t t|�tu � | j�|� d S r )r r
r rI �write�r3 �sr r r rK � s zErrorWrapper.writec C s | j �� d S r )rI �flushrE r r r rN � rG zErrorWrapper.flushc C s |D ]}| � |� qd S r )rK )r3 �seqrA r r r �
writelines� s �zErrorWrapper.writelinesc C rC )Nr z!errors.close() must not be calledrD rE r r r rF � rG zErrorWrapper.closeN)r r r r5 rK rN rP rF r r r r r) � s r) c @ � e Zd Zdd� Zdd� ZdS )r c C r1 r )�writer)r3 Z wsgi_writerr r r r5 � r6 zWriteWrapper.__init__c C s t t|�tu � | �|� d S r )r r
r9 rR rL r r r �__call__� s zWriteWrapper.__call__N)r r r r5 rS r r r r r � � r c @ rQ )�PartialIteratorWrapperc C r1 r �r- )r3 �
wsgi_iteratorr r r r5 r6 z PartialIteratorWrapper.__init__c C s t | jd �S r )r+ r- rE r r r rB s z PartialIteratorWrapper.__iter__N)r r r r5 rB r r r r rU � rT rU c @ rH ) r+ c C s || _ t|�| _d| _|| _d S )NF)�original_iterator�iterr- �closed�check_start_response)r3 rW r[ r r r r5 s
zIteratorWrapper.__init__c C s | S r r rE r r r rB s zIteratorWrapper.__iter__c C sT t | j d� t| j�}t|�turt dd|f � | jd ur(t | jd� d | _|S )NzIterator read after closedFz$Iterator yielded non-bytestring (%r)zjThe application returns and we started iterating over its body, but start_response has not yet been called)r rZ �nextr- r
r9 r[ )r3 r; r r r �__next__ s �
�zIteratorWrapper.__next__c C s$ d| _ t| jd�r| j�� d S d S )NTrF )rZ �hasattrrX rF rE r r r rF s �zIteratorWrapper.closec C s" | j s tj�d� t| j d� d S )Nz/Iterator garbage collected without being closed)rZ �sys�stderrrK r rE r r r �__del__# s ��zIteratorWrapper.__del__N)r r r r5 rB r] rF ra r r r r r+ s r+ c C s� t t| �tu dt| �| f � dD ] }t || v d|f � qdD ]}t || vd||dd � f � q d| vr<t�dt� | �� D ] }d |v rGq@t t| | �tu d
|t| | �| | f � q@t t| d �tu d | d f � t | d
dv d| d
� t | d � t
| d � | d dvr�t�d| d t� t | � d� p�| d � d�d| d � t | � d� p�| d � d�d| d � | � d�r�t t
| d �dkd | d � | � d�s�t d| v d � t | � d�dkd � d S ) Nz:Environment is not of the right type: %r (environment: %r)) �REQUEST_METHODZ SERVER_NAMEZ SERVER_PORT� wsgi.versionr% r& zwsgi.multithreadzwsgi.multiprocessz
wsgi.run_oncez$Environment missing required key: %r)ZHTTP_CONTENT_TYPEZHTTP_CONTENT_LENGTHz8Environment should not have the key: %s (use %s instead)� Z QUERY_STRINGz�QUERY_STRING is not in the WSGI environment; the cgi module will use sys.argv when this variable is missing, so application errors are more likely�.z9Environmental variable %s is not a string: %r (value: %r)rc z#wsgi.version should be a tuple (%r)zwsgi.url_scheme)ZhttpZhttpszwsgi.url_scheme unknown: %rr% r& rb )ZGETZHEADZPOSTZOPTIONSZPATCHZPUTZDELETEZTRACEzUnknown REQUEST_METHOD: %rZ SCRIPT_NAME�/z$SCRIPT_NAME doesn't start with /: %rZ PATH_INFOz"PATH_INFO doesn't start with /: %rZCONTENT_LENGTHr zInvalid CONTENT_LENGTH: %rzgOne of SCRIPT_NAME or PATH_INFO are required (PATH_INFO should at least be '/' if SCRIPT_NAME is empty)zOSCRIPT_NAME cannot be '/'; it should instead be '', and PATH_INFO should be '/')r r
�dict�warnings�warnr �keysr �tuple� check_input� check_errors�get�
startswith�int)r, �keyr r r r' * sx
������ �� �
�
�
�
�
�
��r' c C �& dD ]}t t| |�d| |f � qd S )N)r8 r= r> rB z-wsgi.input (%r) doesn't have the attribute %s�r r^ )r4 �attrr r r rl k �
���rl c C rr )N)rN rK rP z.wsgi.errors (%r) doesn't have the attribute %srs )rJ rt r r r rm q ru rm c C sz t | d�} | �d d�d }tt|�dkd| � t|�}t|dkd| � t| �dk s1| d d kr;t�d
| t� d S d S ) N�Statusr r r z)Status codes must be three characters: %r�d zStatus code is invalid: %r� � zjThe status string (%r) should be a three-digit integer followed by a single space and a status explanation)r �splitr r rp rh ri r )r Z status_codeZ
status_intr r r r w s
����r c C s t t| �tu d| t| �f � | D ]n}t t|�tu d|t|�f � t t|�dk� |\}}t|d�}t|d�}t |�� dkd| � t d|voKd |vd
| � t t�|�d | � t |� d � of|� d
� d| � t
�|�rt dd|t
�|�� d�f � qd S )Nz%Headers (%r) must be of type list: %rz1Individual headers (%r) must be of type tuple: %rr � Header namez Header valuer zyThe Status header cannot be used; it conflicts with CGI script, and HTTP status is not given through headers (value: %r).�
�:z,Header names may not contain ':' or '\n': %rzBad header name: %r�-�_z#Names may not end in '-' or '_': %rr z#Bad header value: %r (bad char: %r)) r r
r? rk r r �lower� header_re�search�endswith�bad_header_value_re�group)r! �item�namer r r r r � sB
��
��
����
���r c C s� t | d�} t| �d d�d �}d}|D ] \}}t |d�}|�� dkr0||vr) d S tdd| � q||vr>tdd| � d S d S ) Nrv r r )�� i0 r{ z content-typezJContent-Type header found in a %s response, which must not return content.z,No Content-Type header found in headers (%s))r rp rz r� r )r r! �codeZNO_MESSAGE_BODYr� r r r r r � s
���r c C s* t | d u p
t| �tu d| t| �f � d S )Nz exc_info (%r) is not a tuple: %r)r r
rk )r" r r r r � s �r c C s t t| ttf� d� d S )NzwYou should not return a string as your application iterator, instead return a single-item list containing a bytestring.)r �
isinstancer r9 rV r r r r* � s �r* )�__all__�rer_ rh �compiler� r� �Warningr r r r r( r) r rU r+ r' rl rm r r r r r* r r r r �<module> s0 j
7# #A __pycache__/validate.cpython-310.opt-1.pyc 0000644 00000034422 15154351672 0014223 0 ustar 00 o
���h�: � @ s� d Z dgZddlZddlZddlZe�d�Ze�d�ZG dd� de�Z dd � Z
d
d � Z d d� Z G d
d� d�Z
G dd� d�ZG dd� d�ZG dd� d�ZG dd� d�Zdd� Zdd� Zdd � Zd d � Zd d � Zd!d"� Zd#d$� Zd%d&� ZdS )'a&
Middleware to check for obedience to the WSGI specification.
Some of the things this checks:
* Signature of the application and start_response (including that
keyword arguments are not used).
* Environment checks:
- Environment is a dictionary (and not a subclass).
- That all the required keys are in the environment: REQUEST_METHOD,
SERVER_NAME, SERVER_PORT, wsgi.version, wsgi.input, wsgi.errors,
wsgi.multithread, wsgi.multiprocess, wsgi.run_once
- That HTTP_CONTENT_TYPE and HTTP_CONTENT_LENGTH are not in the
environment (these headers should appear as CONTENT_LENGTH and
CONTENT_TYPE).
- Warns if QUERY_STRING is missing, as the cgi module acts
unpredictably in that case.
- That CGI-style variables (that don't contain a .) have
(non-unicode) string values
- That wsgi.version is a tuple
- That wsgi.url_scheme is 'http' or 'https' (@@: is this too
restrictive?)
- Warns if the REQUEST_METHOD is not known (@@: probably too
restrictive).
- That SCRIPT_NAME and PATH_INFO are empty or start with /
- That at least one of SCRIPT_NAME or PATH_INFO are set.
- That CONTENT_LENGTH is a positive integer.
- That SCRIPT_NAME is not '/' (it should be '', and PATH_INFO should
be '/').
- That wsgi.input has the methods read, readline, readlines, and
__iter__
- That wsgi.errors has the methods flush, write, writelines
* The status is a string, contains a space, starts with an integer,
and that integer is in range (> 100).
* That the headers is a list (not a subclass, not another kind of
sequence).
* That the items of the headers are tuples of strings.
* That there is no 'status' header (that is used in CGI, but not in
WSGI).
* That the headers don't contain newlines or colons, end in _ or -, or
contain characters codes below 037.
* That Content-Type is given if there is content (CGI often has a
default content type, but WSGI does not).
* That no Content-Type is given when there is no content (@@: is this
too restrictive?)
* That the exc_info argument to start_response is a tuple or None.
* That all calls to the writer are with strings, and no other methods
on the writer are accessed.
* That wsgi.input is used properly:
- .read() is called with exactly one argument
- That it returns a string
- That readline, readlines, and __iter__ return strings
- That .close() is not called
- No other methods are provided
* That wsgi.errors is used properly:
- .write() and .writelines() is called with a string
- That .close() is not called, and no other methods are provided.
* The response iterator:
- That it is not a string (it should be a list of a single string; a
string will work, but perform horribly).
- That .__next__() returns a string
- That the iterator is not iterated over until start_response has
been called (that can signal either a server or application
error).
- That .close() is called (doesn't raise exception, only prints to
sys.stderr, because we only know it isn't called when the object
is garbage collected).
� validator� Nz^[a-zA-Z][a-zA-Z0-9\-_]*$z [\000-\037]c @ s e Zd ZdZdS )� WSGIWarningz:
Raised in response to WSGI-spec-related warnings
N)�__name__�
__module__� __qualname__�__doc__� r r �7/opt/alt/python310/lib64/python3.10/wsgiref/validate.pyr y s r c G s | st |� �d S �N)�AssertionError)Zcond�argsr r r �assert_~ s �r
c C s$ t | �tu r| S td�|t| ����)Nz!{0} must be of type str (got {1}))�type�strr �format�repr)�value�titler r r �check_string_type� s
�r c s � fdd�}|S )a�
When applied between a WSGI server and a WSGI application, this
middleware will check for WSGI compliance on a number of levels.
This middleware does not modify the request or response in any
way, but will raise an AssertionError if anything seems off
(except for a failure to close the application iterator, which
will be printed to stderr -- there's no way to raise an exception
at that point).
c s� t t| �dkd� t | d� | \}� t|� g �� �fdd�}t|d �|d< t|d �|d< �||�}t |d uo=|dkd � t|� t|��S )
N� zTwo arguments required� No keyword arguments allowedc s� t t| �dkp t| �dkd| f � t | d� | d }| d }t| �dkr+| d }nd }t|� t|� t||� t|� ��d � t� | � �S )Nr � z Invalid number of arguments: %sr r � )r
�len� check_status�
check_headers�check_content_type�check_exc_info�append� WriteWrapper)r �kw�status�headers�exc_info�Zstart_responseZstart_response_startedr r �start_response_wrapper� s �
z;validator.<locals>.lint_app.<locals>.start_response_wrapper�
wsgi.input� wsgi.errorsFz>The application must return an iterator, if only an empty list)r
r �
check_environ� InputWrapper� ErrorWrapper�check_iterator�IteratorWrapper)r r �environr% �iterator�� applicationr$ r �lint_app� s
�
zvalidator.<locals>.lint_appr )r0 r1 r r/ r r � s )c @ s< e Zd Zdd� Zdd� Zdd� Zdd� Zd d
� Zd d � Zd
S )r) c C �
|| _ d S r
)�input)�self�
wsgi_inputr r r �__init__� �
zInputWrapper.__init__c G s0 t t|�dk� | jj|� }t t|�tu � |S �Nr )r
r r3 �readr �bytes�r4 r �vr r r r9 � � zInputWrapper.readc G s0 t t|�dk� | jj|� }t t|�tu � |S r8 )r
r r3 �readliner r: r; r r r r> � r= zInputWrapper.readlinec G sJ t t|�dk� | jj|� }t t|�tu � |D ]
}t t|�tu � q|S r8 )r
r r3 � readlinesr �listr: )r4 r �lines�liner r r r? � s zInputWrapper.readlinesc c s � | � � }|s
d S |V qr
)r> )r4 rB r r r �__iter__� s ��zInputWrapper.__iter__c C � t dd� d S )Nr z input.close() must not be called�r
�r4 r r r �close� � zInputWrapper.closeN) r r r r6 r9 r> r? rC rG r r r r r) � s r) c @ �4 e Zd Zdd� Zdd� Zdd� Zdd� Zd d
� Zd S ) r* c C r2 r
)�errors)r4 � wsgi_errorsr r r r6 � r7 zErrorWrapper.__init__c C s t t|�tu � | j�|� d S r
)r
r r rJ �write�r4 �sr r r rL � s zErrorWrapper.writec C s | j �� d S r
)rJ �flushrF r r r rO � rH zErrorWrapper.flushc C s |D ]}| � |� qd S r
)rL )r4 �seqrB r r r �
writelines� s �zErrorWrapper.writelinesc C rD )Nr z!errors.close() must not be calledrE rF r r r rG � rH zErrorWrapper.closeN)r r r r6 rL rO rQ rG r r r r r* � s r* c @ � e Zd Zdd� Zdd� ZdS )r c C r2 r
)�writer)r4 Z wsgi_writerr r r r6 � r7 zWriteWrapper.__init__c C s t t|�tu � | �|� d S r
)r
r r: rS rM r r r �__call__� s zWriteWrapper.__call__N)r r r r6 rT r r r r r � � r c @ rR )�PartialIteratorWrapperc C r2 r
�r. )r4 �
wsgi_iteratorr r r r6 r7 z PartialIteratorWrapper.__init__c C s t | jd �S r
)r, r. rF r r r rC s z PartialIteratorWrapper.__iter__N)r r r r6 rC r r r r rV � rU rV c @ rI ) r, c C s || _ t|�| _d| _|| _d S )NF)�original_iterator�iterr. �closed�check_start_response)r4 rX r\ r r r r6 s
zIteratorWrapper.__init__c C s | S r
r rF r r r rC s zIteratorWrapper.__iter__c C sT t | j d� t| j�}t|�turt dd|f � | jd ur(t | jd� d | _|S )NzIterator read after closedFz$Iterator yielded non-bytestring (%r)zjThe application returns and we started iterating over its body, but start_response has not yet been called)r
r[ �nextr. r r: r\ )r4 r< r r r �__next__ s �
�zIteratorWrapper.__next__c C s$ d| _ t| jd�r| j�� d S d S )NTrG )r[ �hasattrrY rG rF r r r rG s �zIteratorWrapper.closec C s" | j s tj�d� t| j d� d S )Nz/Iterator garbage collected without being closed)r[ �sys�stderrrL r
rF r r r �__del__# s ��zIteratorWrapper.__del__N)r r r r6 rC r^ rG rb r r r r r, s r, c C s� t t| �tu dt| �| f � dD ] }t || v d|f � qdD ]}t || vd||dd � f � q d| vr<t�dt� | �� D ] }d |v rGq@t t| | �tu d
|t| | �| | f � q@t t| d �tu d | d f � t | d
dv d| d
� t | d � t
| d � | d dvr�t�d| d t� t | � d� p�| d � d�d| d � t | � d� p�| d � d�d| d � | � d�r�t t
| d �dkd | d � | � d�s�t d| v d � t | � d�dkd � d S ) Nz:Environment is not of the right type: %r (environment: %r)) �REQUEST_METHODZ SERVER_NAMEZ SERVER_PORT� wsgi.versionr& r' zwsgi.multithreadzwsgi.multiprocessz
wsgi.run_oncez$Environment missing required key: %r)ZHTTP_CONTENT_TYPEZHTTP_CONTENT_LENGTHz8Environment should not have the key: %s (use %s instead)� Z QUERY_STRINGz�QUERY_STRING is not in the WSGI environment; the cgi module will use sys.argv when this variable is missing, so application errors are more likely�.z9Environmental variable %s is not a string: %r (value: %r)rd z#wsgi.version should be a tuple (%r)zwsgi.url_scheme)ZhttpZhttpszwsgi.url_scheme unknown: %rr& r' rc )ZGETZHEADZPOSTZOPTIONSZPATCHZPUTZDELETEZTRACEzUnknown REQUEST_METHOD: %rZ SCRIPT_NAME�/z$SCRIPT_NAME doesn't start with /: %rZ PATH_INFOz"PATH_INFO doesn't start with /: %rZCONTENT_LENGTHr zInvalid CONTENT_LENGTH: %rzgOne of SCRIPT_NAME or PATH_INFO are required (PATH_INFO should at least be '/' if SCRIPT_NAME is empty)zOSCRIPT_NAME cannot be '/'; it should instead be '', and PATH_INFO should be '/')r
r �dict�warnings�warnr �keysr �tuple� check_input� check_errors�get�
startswith�int)r- �keyr r r r( * sx
������ �� �
�
�
�
�
�
��r( c C �& dD ]}t t| |�d| |f � qd S )N)r9 r> r? rC z-wsgi.input (%r) doesn't have the attribute %s�r
r_ )r5 �attrr r r rm k �
���rm c C rs )N)rO rL rQ z.wsgi.errors (%r) doesn't have the attribute %srt )rK ru r r r rn q rv rn c C sz t | d�} | �d d�d }tt|�dkd| � t|�}t|dkd| � t| �dk s1| d d kr;t�d
| t� d S d S ) N�Statusr r r z)Status codes must be three characters: %r�d zStatus code is invalid: %r� � zjThe status string (%r) should be a three-digit integer followed by a single space and a status explanation)r �splitr
r rq ri rj r )r! Z status_codeZ
status_intr r r r w s
����r c C s t t| �tu d| t| �f � | D ]n}t t|�tu d|t|�f � t t|�dk� |\}}t|d�}t|d�}t |�� dkd| � t d|voKd |vd
| � t t�|�d | � t |� d � of|� d
� d| � t
�|�rt dd|t
�|�� d�f � qd S )Nz%Headers (%r) must be of type list: %rz1Individual headers (%r) must be of type tuple: %rr � Header namez Header valuer! zyThe Status header cannot be used; it conflicts with CGI script, and HTTP status is not given through headers (value: %r).�
�:z,Header names may not contain ':' or '\n': %rzBad header name: %r�-�_z#Names may not end in '-' or '_': %rr z#Bad header value: %r (bad char: %r)) r
r r@ rl r r �lower� header_re�search�endswith�bad_header_value_re�group)r" �item�namer r r r r � sB
��
��
����
���r c C s� t | d�} t| �d d�d �}d}|D ] \}}t |d�}|�� dkr0||vr) d S tdd| � q||vr>tdd| � d S d S ) Nrw r r )�� i0 r| z content-typezJContent-Type header found in a %s response, which must not return content.z,No Content-Type header found in headers (%s))r rq r{ r� r
)r! r" �codeZNO_MESSAGE_BODYr� r r r r r � s
���r c C s* t | d u p
t| �tu d| t| �f � d S )Nz exc_info (%r) is not a tuple: %r)r
r rl )r# r r r r � s �r c C s t t| ttf� d� d S )NzwYou should not return a string as your application iterator, instead return a single-item list containing a bytestring.)r
�
isinstancer r: rW r r r r+ � s �r+ )r �__all__�rer` ri �compiler� r� �Warningr r
r r r) r* r rV r, r( rm rn r r r r r+ r r r r �<module> s0 j
7# #A __pycache__/headers.cpython-310.opt-2.pyc 0000644 00000010655 15154351672 0014050 0 ustar 00 o
���hn � @ s0 d dl Z e �d�Zddd�ZG dd� d�ZdS ) � Nz[ \(\)<>@,;:\\"/\[\]\?=]� c C sT |d ur(t |�dkr(|st�|�r"|�dd��dd�}d| |f S d| |f S | S )Nr �\z\\�"z\"z%s="%s"z%s=%s)�len� tspecials�search�replace)Zparam�valueZquote� r
�6/opt/alt/python310/lib64/python3.10/wsgiref/headers.py� _formatparam
s r c @ s� e Zd Z d$dd�Zdd� Zdd� Zdd � Zd
d � Zd d
� Zdd� Z dd� Z
d$dd�Z dd� Z dd� Z
dd� Zdd� Zd d � Zd d � Zd d!� Zd"d#� ZdS )%�HeadersNc C s. |d ur|ng }t |�turtd��|| _d S )Nz+Headers must be a list of name/value tuples)�type�list� TypeError�_headers�_convert_string_type)�selfZheaders�k�vr
r
r �__init__ s
zHeaders.__init__c C s$ t |�tu r |S td�t|����)Nz1Header names/values must be of type str (got {0}))r �str�AssertionError�format�repr)r r r
r
r r ) s
�z Headers._convert_string_typec C s t | j�S �N)r r �r r
r
r �__len__0 s
zHeaders.__len__c C s( | |= | j �| �|�| �|�f� d S r )r �appendr )r �name�valr
r
r � __setitem__4 s
�zHeaders.__setitem__c s2 | � � �� �� � fdd�| jD �| jd d �< d S )Nc s g | ] }|d � � � kr|�qS )r ��lower��.0Zkv�r r
r �
<listcomp>@ s z'Headers.__delitem__.<locals>.<listcomp>�r r# r �r r r
r& r � __delitem__: s "zHeaders.__delitem__c C s | � |�S r ��getr) r
r
r � __getitem__B s
zHeaders.__getitem__c C s | � |�d uS r r+ r) r
r
r � __contains__M s zHeaders.__contains__c s$ | � � �� �� � fdd�| jD �S )Nc s$ g | ]}|d � � � kr|d �qS )r r r" r$ r& r
r r' [ s $ z#Headers.get_all.<locals>.<listcomp>r( r) r
r& r �get_allR s zHeaders.get_allc C s8 | � |�� �}| jD ]\}}|�� |kr| S q |S r r( )r r �defaultr r r
r
r r, ^ s �z Headers.getc C � dd� | j D �S )Nc S s g | ]\}}|�qS r
r
�r% r r r
r
r r' o � z Headers.keys.<locals>.<listcomp>�r r r
r
r �keysg � z Headers.keysc C r1 )Nc S s g | ]\}}|�qS r
r
r2 r
r
r r' y r3 z"Headers.values.<locals>.<listcomp>r4 r r
r
r �valuesq r6 zHeaders.valuesc C s | j d d � S r r4 r r
r
r �items{ s z
Headers.itemsc C s d| j j| jf S )Nz%s(%r))� __class__�__name__r r r
r
r �__repr__� s zHeaders.__repr__c C s d� dd� | jD �ddg �S )Nz
c S s g | ]}d | �qS )z%s: %sr
r$ r
r
r r' � r3 z#Headers.__str__.<locals>.<listcomp>� )�joinr r r
r
r �__str__� s zHeaders.__str__c C s t | ��d�S )Nz
iso-8859-1)r �encoder r
r
r � __bytes__� s zHeaders.__bytes__c C s8 | � |�}|d u r| j�| �|�| �|�f� |S |S r )r, r r r )r r r �resultr
r
r �
setdefault� s
�zHeaders.setdefaultc K s� g }|d ur| � |�}|�|� |�� D ](\}}| � |�}|d u r,|�|�dd�� q| � |�}|�t|�dd�|�� q| j�| � |�d�|�f� d S )N�_�-z; )r r r8 r r r r= )r �_nameZ_valueZ_params�partsr r r
r
r �
add_header� s
zHeaders.add_headerr )r: �
__module__� __qualname__r r r r! r* r- r. r/ r, r5 r7 r8 r; r> r@ rB rG r
r
r
r r
s&
r
)Nr )�re�compiler r r
r
r
r
r �<module> s
__pycache__/__init__.cpython-310.opt-2.pyc 0000644 00000000224 15154351672 0014163 0 ustar 00 o
���hK � @ s d S )N� r r r �7/opt/alt/python310/lib64/python3.10/wsgiref/__init__.py�<module> s __pycache__/__init__.cpython-310.pyc 0000644 00000001347 15154351672 0013232 0 ustar 00 o
���hK � @ s d Z dS )aD wsgiref -- a WSGI (PEP 3333) Reference Library
Current Contents:
* util -- Miscellaneous useful functions and wrappers
* headers -- Manage response headers
* handlers -- base classes for server/gateway implementations
* simple_server -- a simple BaseHTTPServer that supports WSGI
* validate -- validation wrapper that sits between an app and a server
to detect errors in either
To-Do:
* cgi_gateway -- Run WSGI apps under CGI (pending a deployment standard)
* cgi_wrapper -- Run CGI apps under WSGI
* router -- a simple middleware component that handles URL traversal
N)�__doc__� r r �7/opt/alt/python310/lib64/python3.10/wsgiref/__init__.py�<module> s __pycache__/__init__.cpython-310.opt-1.pyc 0000644 00000001347 15154351672 0014171 0 ustar 00 o
���hK � @ s d Z dS )aD wsgiref -- a WSGI (PEP 3333) Reference Library
Current Contents:
* util -- Miscellaneous useful functions and wrappers
* headers -- Manage response headers
* handlers -- base classes for server/gateway implementations
* simple_server -- a simple BaseHTTPServer that supports WSGI
* validate -- validation wrapper that sits between an app and a server
to detect errors in either
To-Do:
* cgi_gateway -- Run WSGI apps under CGI (pending a deployment standard)
* cgi_wrapper -- Run CGI apps under WSGI
* router -- a simple middleware component that handles URL traversal
N)�__doc__� r r �7/opt/alt/python310/lib64/python3.10/wsgiref/__init__.py�<module> s __pycache__/util.cpython-310.opt-1.pyc 0000644 00000012457 15154351672 0013413 0 ustar 00 o
���h� � @ sb d Z ddlZg d�ZG dd� d�Zdd� Zdd � Zdd d �Zd
d� Zdd� Zh d�j Z
dd� Z dS )z$Miscellaneous WSGI-related Utilities� N)� FileWrapper� guess_scheme�application_uri� request_uri�shift_path_info�setup_testing_defaultsc @ s2 e Zd ZdZd dd�Zdd� Zdd� Zd d
� Zd S )
r z1Wrapper to convert file-like objects to iterables� c C s& || _ || _t|d�r|j| _d S d S )N�close)�filelike�blksize�hasattrr )�selfr
r � r �3/opt/alt/python310/lib64/python3.10/wsgiref/util.py�__init__ s
�zFileWrapper.__init__c C s2 dd l }|jdtdd� | j�| j�}|r|S t�)Nr zXFileWrapper's __getitem__ method ignores 'key' parameter. Use iterator protocol instead.� )�
stacklevel)�warnings�warn�DeprecationWarningr
�readr �
IndexError)r
�keyr �datar r r � __getitem__ s �zFileWrapper.__getitem__c C s | S �Nr )r
r r r �__iter__! s zFileWrapper.__iter__c C s | j �| j�}|r |S t�r )r
r r �
StopIteration)r
r r r r �__next__$ s zFileWrapper.__next__N)r )�__name__�
__module__� __qualname__�__doc__r r r r r r r r r s
r c C s | � d�dv r dS dS )zMReturn a guess for whether 'wsgi.url_scheme' should be 'http' or 'https'
ZHTTPS)ZyesZon�1�https�http)�get)�environr r r r * s r c C s� | d d }ddl m} | �d�r|| d 7 }n)|| d 7 }| d dkr3| d d kr2|d
| d 7 }n| d d krA|d
| d 7 }||| �d �pId
dd�7 }|S )z@Return the application's base URI (no PATH_INFO or QUERY_STRING)�wsgi.url_schemez://r ��quote� HTTP_HOST� SERVER_NAMEr$ � SERVER_PORT�443�:�80� SCRIPT_NAME�/�latin1)�encoding)� urllib.parser* r& )r' �urlr* r r r r 2 s
� r Tc C sp t | �}ddlm} || �dd�ddd�}| �d�s#||d d
� 7 }n||7 }|r6| �d �r6|d | d 7 }|S )
zBReturn the full request URI, optionally including the query stringr r) � PATH_INFO� z/;=,r3 )Zsafer4 r1 � NZ QUERY_STRING�?)r r5 r* r& )r' Z
include_queryr6 r* � path_infor r r r F s
r c C s� | � dd�}|s
dS |�d�}dd� |dd� D �|dd�< |d }|d= | � d d�}t�|d | �}|�d�r?|dd� }|sJ|�d�sJ|d7 }|| d < d�|�| d< |d
kr[d}|S ) aZ Shift a name from PATH_INFO to SCRIPT_NAME, returning it
If there are no remaining path segments in PATH_INFO, return None.
Note: 'environ' is modified in-place; use a copy if you need to keep
the original PATH_INFO or SCRIPT_NAME.
Note: when PATH_INFO is just a '/', this returns '' and appends a trailing
'/' to SCRIPT_NAME, even though empty path segments are normally ignored,
and SCRIPT_NAME doesn't normally end in a '/'. This is intentional
behavior, to ensure that an application can tell the difference between
'/x' and '/x/' when traversing to objects.
r7 r8 Nr2 c S s g | ]
}|r|d kr|�qS )�.r )�.0�pr r r �
<listcomp>e s z#shift_path_info.<locals>.<listcomp>r9 ���r1 r< )r& �split� posixpath�normpath�endswith�join)r' r; �
path_parts�nameZ script_namer r r r S s$
r c C s | � dd� | � dd� | � d| d � | � dd� d| vr.d | vr.| � dd
� | � d d � | � d d
� | � dd� | � dd� | � dd� ddlm}m} | � d|� � | � d|� � | � dt| �� | d dkrr| � dd� dS | d dkr�| � dd� dS dS ) a: Update 'environ' with trivial defaults for testing purposes
This adds various parameters required for WSGI, including HTTP_HOST,
SERVER_NAME, SERVER_PORT, REQUEST_METHOD, SCRIPT_NAME, PATH_INFO,
and all of the wsgi.* variables. It only supplies default values,
and does not replace any existing settings for these variables.
This routine is intended to make it easier for unit tests of WSGI
servers and applications to set up dummy environments. It should *not*
be used by actual WSGI servers or applications, since the data is fake!
r, z 127.0.0.1ZSERVER_PROTOCOLzHTTP/1.0r+ ZREQUEST_METHODZGETr1 r7 r8 r2 z wsgi.version)r9 r z
wsgi.run_oncer zwsgi.multithreadzwsgi.multiprocess)�StringIO�BytesIOz
wsgi.inputz wsgi.errorsr( r% r- r0 r$ r. N)�
setdefault�iorH rI r )r' rH rI r r r r | s(
�r > zproxy-authenticateZupgradeztransfer-encodingz
keep-alive�teZtrailerszproxy-authorizationZ
connectionc C s t | �� �S )z?Return true if 'header_name' is an HTTP/1.1 "Hop-by-Hop" header)�_hoppish�lower)Z header_namer r r �
is_hop_by_hop� s rO )T) r" rB �__all__r r r r r r � __contains__rM rO r r r r �<module> s
)(� __pycache__/headers.cpython-310.opt-1.pyc 0000644 00000017007 15154351672 0014045 0 ustar 00 o
���hn � @ s2 d Z ddlZe�d�Zd dd�ZG dd� d�ZdS )
z�Manage HTTP Response Headers
Much of this module is red-handedly pilfered from email.message in the stdlib,
so portions are Copyright (C) 2001,2002 Python Software Foundation, and were
written by Barry Warsaw.
� Nz[ \(\)<>@,;:\\"/\[\]\?=]� c C sR |dur't |�dkr'|st�|�r!|�dd��dd�}d| |f S d| |f S | S ) z~Convenience function to format and return a key=value pair.
This will quote the value if needed or if quote is true.
Nr �\z\\�"z\"z%s="%s"z%s=%s)�len� tspecials�search�replace)Zparam�valueZquote� r
�6/opt/alt/python310/lib64/python3.10/wsgiref/headers.py� _formatparam
s r c @ s� e Zd ZdZd%dd�Zdd� Zdd� Zd d
� Zd d � Zd
d� Z dd� Z
dd� Z d%dd�Z dd� Z
dd� Zdd� Zdd � Zd d � Zd d � Zd!d"� Zd#d$� ZdS )&�Headersz,Manage a collection of HTTP response headersNc C s. |d ur|ng }t |�turtd��|| _d S )Nz+Headers must be a list of name/value tuples)�type�list� TypeError�_headers�_convert_string_type)�selfZheaders�k�vr
r
r �__init__ s
zHeaders.__init__c C s" t |�tu r|S td�t|����)zConvert/check value type.z1Header names/values must be of type str (got {0}))r �str�AssertionError�format�repr)r r r
r
r r ) s
�z Headers._convert_string_typec C s
t | j�S )z9Return the total number of headers, including duplicates.)r r �r r
r
r �__len__0 s
zHeaders.__len__c C s& | |= | j �| �|�| �|�f� dS )zSet the value of a header.N)r �appendr )r �name�valr
r
r � __setitem__4 s �zHeaders.__setitem__c s0 | � � �� �� � fdd�| jD �| jdd�< dS )zyDelete all occurrences of a header, if present.
Does *not* raise an exception if the header is missing.
c s g | ] }|d � � � kr|�qS )r ��lower��.0Zkv�r r
r �
<listcomp>@ s z'Headers.__delitem__.<locals>.<listcomp>N�r r" r �r r r
r% r � __delitem__: s "zHeaders.__delitem__c C s
| � |�S )aH Get the first header value for 'name'
Return None if the header is missing instead of raising an exception.
Note that if the header appeared multiple times, the first exactly which
occurrence gets returned is undefined. Use getall() to get all
the values matching a header field name.
��getr( r
r
r � __getitem__B s
zHeaders.__getitem__c C s | � |�duS )z/Return true if the message contains the header.Nr* r( r
r
r � __contains__M s zHeaders.__contains__c s" | � � �� �� � fdd�| jD �S )aq Return a list of all the values for the named field.
These will be sorted in the order they appeared in the original header
list or were added to this instance, and may contain duplicates. Any
fields deleted and re-inserted are always appended to the header list.
If no fields exist with the given name, returns an empty list.
c s$ g | ]}|d � � � kr|d �qS )r r r! r# r% r
r r& [ s $ z#Headers.get_all.<locals>.<listcomp>r' r( r
r% r �get_allR s zHeaders.get_allc C s6 | � |�� �}| jD ]\}}|�� |kr| S q
|S )z:Get the first header value for 'name', or return 'default'r' )r r �defaultr r r
r
r r+ ^ s �z Headers.getc C � dd� | j D �S )a* Return a list of all the header field names.
These will be sorted in the order they appeared in the original header
list, or were added to this instance, and may contain duplicates.
Any fields deleted and re-inserted are always appended to the header
list.
c S s g | ]\}}|�qS r
r
�r$ r r r
r
r r& o � z Headers.keys.<locals>.<listcomp>�r r r
r
r �keysg � z Headers.keysc C r0 )a! Return a list of all header values.
These will be sorted in the order they appeared in the original header
list, or were added to this instance, and may contain duplicates.
Any fields deleted and re-inserted are always appended to the header
list.
c S s g | ]\}}|�qS r
r
r1 r
r
r r& y r2 z"Headers.values.<locals>.<listcomp>r3 r r
r
r �valuesq r5 zHeaders.valuesc C s | j dd� S )a Get all the header fields and values.
These will be sorted in the order they were in the original header
list, or were added to this instance, and may contain duplicates.
Any fields deleted and re-inserted are always appended to the header
list.
Nr3 r r
r
r �items{ s z
Headers.itemsc C s d| j j| jf S )Nz%s(%r))� __class__�__name__r r r
r
r �__repr__� s zHeaders.__repr__c C s d� dd� | jD �ddg �S )zkstr() returns the formatted headers, complete with end line,
suitable for direct HTTP transmission.z
c S s g | ]}d | �qS )z%s: %sr
r# r
r
r r& � r2 z#Headers.__str__.<locals>.<listcomp>� )�joinr r r
r
r �__str__� s zHeaders.__str__c C s t | ��d�S )Nz
iso-8859-1)r �encoder r
r
r � __bytes__� s zHeaders.__bytes__c C s6 | � |�}|du r| j�| �|�| �|�f� |S |S )z�Return first matching header value for 'name', or 'value'
If there is no header named 'name', add a new header with name 'name'
and value 'value'.N)r+ r r r )r r r �resultr
r
r �
setdefault� s
�zHeaders.setdefaultc K s� g }|dur| � |�}|�|� |�� D ](\}}| � |�}|du r+|�|�dd�� q| � |�}|�t|�dd�|�� q| j�| � |�d�|�f� dS )af Extended header setting.
_name is the header field to add. keyword arguments can be used to set
additional parameters for the header field, with underscores converted
to dashes. Normally the parameter will be added as key="value" unless
value is None, in which case only the key will be added.
Example:
h.add_header('content-disposition', 'attachment', filename='bud.gif')
Note that unlike the corresponding 'email.message' method, this does
*not* handle '(charset, language, value)' tuples: all values must be
strings or None.
N�_�-z; )r r r7 r r r r< )r �_nameZ_valueZ_params�partsr r r
r
r �
add_header� s
zHeaders.add_header)N)r9 �
__module__� __qualname__�__doc__r r r r r) r, r- r. r+ r4 r6 r7 r: r= r? rA rF r
r
r
r r
s&
r
)Nr )rI �re�compiler r r
r
r
r
r �<module> s
__pycache__/util.cpython-310.pyc 0000644 00000012457 15154351672 0012454 0 ustar 00 o
���h� � @ sb d Z ddlZg d�ZG dd� d�Zdd� Zdd � Zdd d �Zd
d� Zdd� Zh d�j Z
dd� Z dS )z$Miscellaneous WSGI-related Utilities� N)� FileWrapper� guess_scheme�application_uri� request_uri�shift_path_info�setup_testing_defaultsc @ s2 e Zd ZdZd dd�Zdd� Zdd� Zd d
� Zd S )
r z1Wrapper to convert file-like objects to iterables� c C s& || _ || _t|d�r|j| _d S d S )N�close)�filelike�blksize�hasattrr )�selfr
r � r �3/opt/alt/python310/lib64/python3.10/wsgiref/util.py�__init__ s
�zFileWrapper.__init__c C s2 dd l }|jdtdd� | j�| j�}|r|S t�)Nr zXFileWrapper's __getitem__ method ignores 'key' parameter. Use iterator protocol instead.� )�
stacklevel)�warnings�warn�DeprecationWarningr
�readr �
IndexError)r
�keyr �datar r r � __getitem__ s �zFileWrapper.__getitem__c C s | S �Nr )r
r r r �__iter__! s zFileWrapper.__iter__c C s | j �| j�}|r |S t�r )r
r r �
StopIteration)r
r r r r �__next__$ s zFileWrapper.__next__N)r )�__name__�
__module__� __qualname__�__doc__r r r r r r r r r s
r c C s | � d�dv r dS dS )zMReturn a guess for whether 'wsgi.url_scheme' should be 'http' or 'https'
ZHTTPS)ZyesZon�1�https�http)�get)�environr r r r * s r c C s� | d d }ddl m} | �d�r|| d 7 }n)|| d 7 }| d dkr3| d d kr2|d
| d 7 }n| d d krA|d
| d 7 }||| �d �pId
dd�7 }|S )z@Return the application's base URI (no PATH_INFO or QUERY_STRING)�wsgi.url_schemez://r ��quote� HTTP_HOST� SERVER_NAMEr$ � SERVER_PORT�443�:�80� SCRIPT_NAME�/�latin1)�encoding)� urllib.parser* r& )r' �urlr* r r r r 2 s
� r Tc C sp t | �}ddlm} || �dd�ddd�}| �d�s#||d d
� 7 }n||7 }|r6| �d �r6|d | d 7 }|S )
zBReturn the full request URI, optionally including the query stringr r) � PATH_INFO� z/;=,r3 )Zsafer4 r1 � NZ QUERY_STRING�?)r r5 r* r& )r' Z
include_queryr6 r* � path_infor r r r F s
r c C s� | � dd�}|s
dS |�d�}dd� |dd� D �|dd�< |d }|d= | � d d�}t�|d | �}|�d�r?|dd� }|sJ|�d�sJ|d7 }|| d < d�|�| d< |d
kr[d}|S ) aZ Shift a name from PATH_INFO to SCRIPT_NAME, returning it
If there are no remaining path segments in PATH_INFO, return None.
Note: 'environ' is modified in-place; use a copy if you need to keep
the original PATH_INFO or SCRIPT_NAME.
Note: when PATH_INFO is just a '/', this returns '' and appends a trailing
'/' to SCRIPT_NAME, even though empty path segments are normally ignored,
and SCRIPT_NAME doesn't normally end in a '/'. This is intentional
behavior, to ensure that an application can tell the difference between
'/x' and '/x/' when traversing to objects.
r7 r8 Nr2 c S s g | ]
}|r|d kr|�qS )�.r )�.0�pr r r �
<listcomp>e s z#shift_path_info.<locals>.<listcomp>r9 ���r1 r< )r& �split� posixpath�normpath�endswith�join)r' r; �
path_parts�nameZ script_namer r r r S s$
r c C s | � dd� | � dd� | � d| d � | � dd� d| vr.d | vr.| � dd
� | � d d � | � d d
� | � dd� | � dd� | � dd� ddlm}m} | � d|� � | � d|� � | � dt| �� | d dkrr| � dd� dS | d dkr�| � dd� dS dS ) a: Update 'environ' with trivial defaults for testing purposes
This adds various parameters required for WSGI, including HTTP_HOST,
SERVER_NAME, SERVER_PORT, REQUEST_METHOD, SCRIPT_NAME, PATH_INFO,
and all of the wsgi.* variables. It only supplies default values,
and does not replace any existing settings for these variables.
This routine is intended to make it easier for unit tests of WSGI
servers and applications to set up dummy environments. It should *not*
be used by actual WSGI servers or applications, since the data is fake!
r, z 127.0.0.1ZSERVER_PROTOCOLzHTTP/1.0r+ ZREQUEST_METHODZGETr1 r7 r8 r2 z wsgi.version)r9 r z
wsgi.run_oncer zwsgi.multithreadzwsgi.multiprocess)�StringIO�BytesIOz
wsgi.inputz wsgi.errorsr( r% r- r0 r$ r. N)�
setdefault�iorH rI r )r' rH rI r r r r | s(
�r > zproxy-authenticateZupgradeztransfer-encodingz
keep-alive�teZtrailerszproxy-authorizationZ
connectionc C s t | �� �S )z?Return true if 'header_name' is an HTTP/1.1 "Hop-by-Hop" header)�_hoppish�lower)Z header_namer r r �
is_hop_by_hop� s rO )T) r" rB �__all__r r r r r r � __contains__rM rO r r r r �<module> s
)(� __pycache__/simple_server.cpython-310.opt-2.pyc 0000644 00000010731 15154351672 0015307 0 ustar 00 o
���h3 � @ s2 d dl mZmZ d dlZd dlZd dlmZ d dlm Z dZ
g d�Z de
Z e � d ej
�� d Ze d e ZG d
d � d e�ZG d d
� d
e�ZG dd� de�Zdd� Zeefdd�Zedkr�edde��'Zej�� Zeded ded d� d dl Z e � d� e� � W d � dS 1 s�w Y dS dS ) � )�BaseHTTPRequestHandler�
HTTPServerN)�
SimpleHandler)�python_implementationz0.2)�
WSGIServer�WSGIRequestHandler�demo_app� make_server� WSGIServer/�/� c @ s e Zd ZeZdd� ZdS )�
ServerHandlerc C s< z| j �| j�dd�d | j� W t�| � d S t�| � w )Nr � r )�request_handlerZ log_requestZstatus�splitZ
bytes_sentr �close��self� r �</opt/alt/python310/lib64/python3.10/wsgiref/simple_server.pyr s
�zServerHandler.closeN)�__name__�
__module__� __qualname__�software_versionZserver_softwarer r r r r r
s r
c @ s2 e Zd Z dZdd� Zdd� Zdd� Zdd � ZdS )
r Nc C s t �| � | �� d S �N)r � server_bind�
setup_environr r r r r 0 s
zWSGIServer.server_bindc C sF i }| _ | j|d< d|d< t| j�|d< d|d< d|d< d|d< d S ) NZ SERVER_NAMEzCGI/1.1ZGATEWAY_INTERFACEZ SERVER_PORT� � REMOTE_HOST�CONTENT_LENGTHZ SCRIPT_NAME)� base_environZ server_name�strZ server_port)r �envr r r r 5 s
zWSGIServer.setup_environc C s | j S r �� applicationr r r r �get_app? � zWSGIServer.get_appc C s
|| _ d S r r# )r r$ r r r �set_appB s
zWSGIServer.set_app)r r r r$ r r r% r' r r r r r * s
r c @ s, e Zd Zde Zdd� Zdd� Zdd� ZdS ) r r
c C sL | j j�� }| j|d< | j|d< | j|d< d| jv r$| j�dd�\}}n| jd}}tj �
|d�|d< ||d < | � � }|| j d
krF||d < | j d
|d < | j
�d
�d u r]| j
�� |d< n| j
d
|d< | j
�d�}|rp||d< | j
�� D ].\}}|�dd��� }|�� }||v r�qud| |v r�|d| d| 7 < qu||d| < qu|S )NZSERVER_PROTOCOLZSERVER_SOFTWAREZREQUEST_METHOD�?r r z
iso-8859-1Z PATH_INFOZ QUERY_STRINGr r Z REMOTE_ADDRz content-typeZ CONTENT_TYPEzcontent-lengthr �-�_ZHTTP_�,)�serverr �copy�request_version�server_version�command�pathr �urllib�parseZunquoteZaddress_stringZclient_addressZheaders�getZget_content_type�items�replace�upper�strip)r r" r1 Zquery�hostZlength�k�vr r r � get_environK s6
z WSGIRequestHandler.get_environc C s t jS r )�sys�stderrr r r r �
get_stderrp r& z WSGIRequestHandler.get_stderrc C s� | j �d�| _t| j�dkr d| _d| _d| _| �d� d S | �� s%d S t | j | j
| � � | � � dd�}| |_
|�| j�� � d S )Ni i r i� F)Z multithread)Zrfile�readlineZraw_requestline�lenZ requestliner. r0 Z
send_errorZ
parse_requestr
Zwfiler? r< r �runr, r% )r Zhandlerr r r �handles s
�zWSGIRequestHandler.handleN)r r r � __version__r/ r< r? rC r r r r r G s
% r c C sr ddl m} |� }td|d� t|d� t| �� �}|D ]\}}t|dt|�|d� q |ddg� |�� �d�gS ) Nr )�StringIOz Hello world!)�file�=z200 OK)z Content-Typeztext/plain; charset=utf-8zutf-8)�iorE �print�sortedr5 �repr�getvalue�encode)�environZstart_responserE �stdout�hr: r; r r r r � s
r c C s || |f|�}|� |� |S r )r' )r9 �portZappZ server_classZ
handler_classr, r r r r � s
r �__main__r i@ zServing HTTP onrQ r z...z http://localhost:8000/xyz?abc) Z http.serverr r r= Z urllib.parser2 Zwsgiref.handlersr �platformr rD �__all__r/ �versionr � sys_versionr r
r r r r r ZhttpdZsocketZ getsocknameZsarI Z
webbrowser�openZhandle_requestr r r r �<module> s4 C
�
"�� __pycache__/handlers.cpython-310.pyc 0000644 00000040036 15154351672 0013271 0 ustar 00 o
���h�T � @ s� d Z ddlmZmZmZ ddlmZ ddlZddlZddl Z g d�Z
g d�Z g d�Z d d
� Z
h d �jZd d
� Zdd� ZG dd� d�ZG dd� de�ZG dd� de�ZG dd� de�ZG dd� de�ZdS )z/Base classes for server/gateway implementations� )� FileWrapper� guess_scheme�
is_hop_by_hop)�Headers� N)� BaseHandler�
SimpleHandler�BaseCGIHandler�
CGIHandler�
IISCGIHandler� read_environ)ZMonZTueZWedZThuZFriZSatZSun)
NZJanZFebZMarZAprZMayZJunZJulZAugZSepZOctZNovZDecc
C s: t �| �\ }}}}}}}}} dt| |t| ||||f S )Nz#%s, %02d %3s %4d %02d:%02d:%02d GMT)�time�gmtime� _weekdayname�
_monthname)
Z timestampZyearZmonthZdayZhhZmmZssZwd�y�z� r �7/opt/alt/python310/lib64/python3.10/wsgiref/handlers.py�format_date_time s �r >
Z CONTENT_TYPE� PATH_INFOZCONTENT_LENGTHZ REMOTE_USERZREQUEST_METHODZHTTPS� SCRIPT_NAMEZ AUTH_TYPEZ QUERY_STRINGZ REMOTE_IDENTc C s6 t | �p| �d�p| �d�p| �d�ot| dd � �S )NZHTTP_ZSSL_Z REDIRECT_� )� _is_request�
startswith�_needs_transcode)�kr r r r s �r c C s� t �� } d}zd�d|� W n ty d}Y nw i }tj�� D ]S\}}t|�rpt jdkrgtj� dd��
� }|� d�rE|�d�� d�}n+|� d �rKn%|� d
�r]d |v r]|�d�� d�}n|�| d�� d�}n |�| |�� d�}|||< q!|S ) z'Read environment, fixing HTTP variables�surrogateescape� zutf-8�replaceZwin32�SERVER_SOFTWAREzmicrosoft-iis/�
iso-8859-1zapache/z simplehttp/zpython/3)
�sys�getfilesystemencoding�encode� LookupError�os�environ�itemsr �platform�get�lowerr �decode)�encZescr' r �vZsoftwarer r r r " s0 �
�
r c @ s" e Zd ZdZdZdZdZdZdZdZ dZ
e � Z e
ZeZdZdZdgZd Zd ZZdZdZd
Zd d � Zd
d� Zdd� Z dd� Z dd� Z dd� Z d;dd�Z dd� Z!dd � Z"d d � Z#d d � Z$d!d"� Z%d#d$� Z&d%d&� Z'd'd(� Z(d)d*� Z)d+d,� Z*d-d.� Z+d/d0� Z,d1d2� Z-d3d4� Z.d5d6� Z/d7d8� Z0d9d:� Z1dS )<r z+Manage the invocation of a WSGI application)r r TFz1.0Nz500 Internal Server Error)z Content-Typez
text/plains; A server error occurred. Please contact the administrator.r c
C sh z| � � || j| j�| _| �� W dS tttfy Y dS z| �� W Y dS | � � � )zInvoke the applicationN)
�
setup_environr' �start_response�result�finish_response�ConnectionAbortedError�BrokenPipeError�ConnectionResetError� handle_error�close)�selfZ applicationr r r �run� s zBaseHandler.runc C s� | j �� }| _| �� | �� |d< | �� |d< | j|d< | j|d< | �� |d< | j |d< | j
|d< | j dur<| j |d < | j rK| j
rM|�d
| j
� dS dS dS ) z&Set up the environment for one requestz
wsgi.inputz wsgi.errorsz wsgi.versionz
wsgi.run_oncezwsgi.url_schemezwsgi.multithreadzwsgi.multiprocessNzwsgi.file_wrapperr )�
os_environ�copyr' � add_cgi_vars� get_stdin�
get_stderr� wsgi_version�
wsgi_run_once�
get_scheme�wsgi_multithread�wsgi_multiprocess�wsgi_file_wrapper�
origin_server�server_software�
setdefault)r8 �envr r r r/ � s
�zBaseHandler.setup_environc C s^ z| � � r | �� s| jD ]}| �|� q | �� W n t| jd�r(| j�� � | �� dS )a> Send any iterable data, then close self and the iterable
Subclasses intended for use in asynchronous servers will
want to redefine this method, such that it sets up callbacks
in the event loop to iterate over the data, and to call
'self.close()' once the response is finished.
r7 N)�result_is_file�sendfiler1 �write�finish_content�hasattrr7 �r8 �datar r r r2 � s
�
zBaseHandler.finish_responsec C s
t | j�S )z Return the URL scheme being used)r r' �r8 r r r rA � s
zBaseHandler.get_schemec
C sJ zt | j�}W n
tttfy Y dS w |dkr#t| j�| jd< dS dS )z@Compute Content-Length or switch to chunked encoding if possibler �Content-LengthN)�lenr1 � TypeError�AttributeError�NotImplementedError�str�
bytes_sent�headers)r8 Zblocksr r r �set_content_length� s ��z BaseHandler.set_content_lengthc C s d| j vr | �� dS dS )zqMake any necessary header changes or defaults
Subclasses can extend this to add other defaults.
rQ N)rX rY rP r r r �cleanup_headers� s
�zBaseHandler.cleanup_headersc C s� |rz| j r|d |d ��|d ��W d}n d}w | jdur#td��|| _| �|�| _| �|d�}t|�dks<J d��|dd � �� sHJ d
��|d d ksRJ d �� |D ] \}}| �|d�}| �|d�}t |�rtJ d|� d|� d���qU| j
S )z4'start_response()' callable as specified by PEP 3333r r � NzHeaders already set!ZStatus� z$Status must be at least 4 characters� z(Status message must begin w/3-digit code� z+Status message must have a space after codeTz Header namez Header valuezHop-by-hop header, 'z: z', not allowed) � headers_sent�with_tracebackrX �AssertionError�status�
headers_class�_convert_string_typerR �isdigitr rK )r8 rb rX �exc_info�name�valr r r r0 � s, �
�zBaseHandler.start_responsec C s$ t |�tu r|S td�|t|����)zConvert/check value type.z!{0} must be of type str (got {1}))�typerV ra �format�repr)r8 �value�titler r r rd � s
�z BaseHandler._convert_string_typec C s� | j rC| �� r=| �d| j| jf �d�� d| jvr(| �dtt�� � �d�� | j r?d| jvrA| �d| j �d�� dS dS dS dS | �d| j �d�� dS ) z6Transmit version/status/date/server, via self._write()z HTTP/%s %s
r! ZDatez
Date: %s
ZServerz Server: %s
z Status: %s
N)
rE �client_is_modern�_write� http_versionrb r$ rX r r
rF rP r r r �
send_preamble s
��zBaseHandler.send_preamblec C sd t |�tu s
J d��| jstd��| js t|�| _| �� n | jt|�7 _| �|� | � � dS )z+'write()' callable as specified by PEP 3333z)write() argument must be a bytes instancez write() before start_response()N)
ri �bytesrb ra r_ rR rW � send_headersro �_flushrN r r r rK s �
zBaseHandler.writec C s dS )a Platform-specific file transmission
Override this method in subclasses to support platform-specific
file transmission. It is only called if the application's
return iterable ('self.result') is an instance of
'self.wsgi_file_wrapper'.
This method should return a true value if it was able to actually
transmit the wrapped file-like object using a platform-specific
approach. It should return a false value if normal iteration
should be used instead. An exception can be raised to indicate
that transmission was attempted, but failed.
NOTE: this method should call 'self.send_headers()' if
'self.headers_sent' is false and it is going to attempt direct
transmission of the file.
Fr rP r r r rJ ) s zBaseHandler.sendfilec C s& | j s| j�dd� | �� dS dS )z.Ensure headers and content have both been sentrQ �0N)r_ rX rG rs rP r r r rL > s zBaseHandler.finish_contentc C s� z5t | jd�r!| j�� W d | _ | _ | _| _d| _d| _dS W d | _ | _ | _| _d| _d| _dS d | _ | _ | _| _d| _d| _w )z�Close the iterable (if needed) and reset all instance vars
Subclasses may want to also drop the client connection.
r7 Nr F)rM r1 r7 rX rb r' rW r_ rP r r r r7 H s ��zBaseHandler.closec C s< | � � d| _| jr| �� r | �� | �t| j�� dS dS )z1Transmit headers to the client, via self._write()TN)rZ r_ rE rn rq ro rr rX rP r r r rs U s �zBaseHandler.send_headersc C s | j }|duo t| j|�S )z@True if 'self.result' is an instance of 'self.wsgi_file_wrapper'N)rD �
isinstancer1 )r8 �wrapperr r r rI ^ s zBaseHandler.result_is_filec C s | j d �� dkS )z,True if client can accept status and headersZSERVER_PROTOCOLzHTTP/0.9)r' �upperrP r r r rn d s z BaseHandler.client_is_modernc C sL z"ddl m} | �� }||d |d |d | j|� |�� W d}dS d}w )z�Log the 'exc_info' tuple in the server log
Subclasses may override to retarget the output or change its format.
r )�print_exceptionr r[ N)� tracebackry r> �traceback_limit�flush)r8 rf ry �stderrr r r �
log_exceptioni s �
zBaseHandler.log_exceptionc C s6 | � t�� � | js| �| j| j�| _| �� dS dS )z>Log current error, and send error output to client if possibleN) r~ r" rf r_ � error_outputr' r0 r1 r2 rP r r r r6 y s
�zBaseHandler.handle_errorc C s$ || j | jdd� t�� � | jgS )aZ WSGI mini-app to create error output
By default, this just uses the 'error_status', 'error_headers',
and 'error_body' attributes to generate an output page. It can
be overridden in a subclass to dynamically generate diagnostics,
choose an appropriate message for the user's preferred language, etc.
Note, however, that it's not recommended from a security perspective to
spit out diagnostics to any old user; ideally, you should have to do
something special to enable diagnostic output, which is why we don't
include any here!
N)� error_status�
error_headersr" rf �
error_body)r8 r' r0 r r r r � s
zBaseHandler.error_outputc C � t �)a Override in subclass to buffer data for send to client
It's okay if this method actually transmits the data; BaseHandler
just separates write and flush operations for greater efficiency
when the underlying system actually has such a distinction.
�rU rN r r r ro � s zBaseHandler._writec C r� )z�Override in subclass to force sending of recent '_write()' calls
It's okay if this method is a no-op (i.e., if '_write()' actually
sends the data.
r� rP r r r rt � s zBaseHandler._flushc C r� )z4Override in subclass to return suitable 'wsgi.input'r� rP r r r r= � � zBaseHandler.get_stdinc C r� )z5Override in subclass to return suitable 'wsgi.errors'r� rP r r r r> � r� zBaseHandler.get_stderrc C r� )z>Override in subclass to insert CGI variables in 'self.environ'r� rP r r r r< � r� zBaseHandler.add_cgi_vars�N)2�__name__�
__module__� __qualname__�__doc__r? rB rC r@ rE rp rF r r: r rD r rc r{ r� r� r� rb r1 r_ rX rW r9 r/ r2 rA rY rZ r0 rd rq rK rJ rL r7 rs rI rn r~ r6 r ro rt r= r> r< r r r r r ^ sX
r c @ sD e Zd ZdZ ddd�Zdd� Zdd � Zd
d � Zd d
� Zdd� Z dS )r aq Handler that's just initialized with streams, environment, etc.
This handler subclass is intended for synchronous HTTP/1.0 origin servers,
and handles sending the entire response output, given the correct inputs.
Usage::
handler = SimpleHandler(
inp,out,err,env, multithread=False, multiprocess=True
)
handler.run(app)TFc C s( || _ || _|| _|| _|| _|| _d S r� )�stdin�stdoutr} �base_envrB rC )r8 r� r� r} r' � multithread� multiprocessr r r �__init__� s
zSimpleHandler.__init__c C � | j S r� )r� rP r r r r= � � zSimpleHandler.get_stdinc C r� r� )r} rP r r r r> � r� zSimpleHandler.get_stderrc C s | j �| j� d S r� )r' �updater� rP r r r r< � s zSimpleHandler.add_cgi_varsc C s^ | j �|�}|d u s|t|�krd S ddlm} |dt� ||d � }|s(d S | j �|�}q )Nr )�warnz9SimpleHandler.stdout.write() should not do partial writes)r� rK rR �warningsr� �DeprecationWarning)r8 rO r1 r� r r r ro � s � �zSimpleHandler._writec C s | j �� | j j| _d S r� )r� r| rt rP r r r rt � s
zSimpleHandler._flushN)TF)
r� r� r� r� r� r= r> r< ro rt r r r r r � s
�
r c @ s e Zd ZdZdZdS )r a� CGI-like systems using input/output/error streams and environ mapping
Usage::
handler = BaseCGIHandler(inp,out,err,env)
handler.run(app)
This handler class is useful for gateway protocols like ReadyExec and
FastCGI, that have usable input/output/error streams and an environment
mapping. It's also the base class for CGIHandler, which just uses
sys.stdin, os.environ, and so on.
The constructor also takes keyword arguments 'multithread' and
'multiprocess' (defaulting to 'True' and 'False' respectively) to control
the configuration sent to the application. It sets 'origin_server' to
False (to enable CGI-like output), and assumes that 'wsgi.run_once' is
False.
FN)r� r� r� r� rE r r r r r � s r c @ � e Zd ZdZdZi Zdd� ZdS )r
a� CGI-based invocation via sys.stdin/stdout/stderr and os.environ
Usage::
CGIHandler().run(app)
The difference between this class and BaseCGIHandler is that it always
uses 'wsgi.run_once' of 'True', 'wsgi.multithread' of 'False', and
'wsgi.multiprocess' of 'True'. It does not take any initialization
parameters, but always uses 'sys.stdin', 'os.environ', and friends.
If you need to override any of these parameters, use BaseCGIHandler
instead.
Tc C s( t j| tjjtjjtjt� ddd� d S )NFT�r� r� )r r� r" r� �bufferr� r} r rP r r r r� s
�zCGIHandler.__init__N�r� r� r� r� r@ r: r� r r r r r
� s
r
c @ r� )r a CGI-based invocation with workaround for IIS path bug
This handler should be used in preference to CGIHandler when deploying on
Microsoft IIS without having set the config allowPathInfo option (IIS>=7)
or metabase allowPathInfoForScriptMappings (IIS<7).
Tc C sj t � }|�dd�}|�dd�}|d �|d �r"|t|�d � |d< tj| tjjtj jtj
|ddd� d S )Nr r r �/FTr� ) r r* r rR r r� r" r� r� r� r} )r8 r' �pathZscriptr r r r� 2 s
�zIISCGIHandler.__init__Nr� r r r r r s
r )r� �utilr r r rX r r" r& r
�__all__r r r � __contains__r r r r r r r
r r r r r �<module> s( �< V2 __pycache__/handlers.cpython-310.opt-2.pyc 0000644 00000024655 15154351672 0014242 0 ustar 00 o
���h�T � @ s� d dl mZmZmZ d dlmZ ddlZddlZddlZg d�Z g d�Z
g d�Z dd � Z h d
�j
Zd d � Zd
d� ZG dd� d�ZG dd� de�ZG dd� de�ZG dd� de�ZG dd� de�ZdS )� )� FileWrapper� guess_scheme�
is_hop_by_hop)�Headers� N)� BaseHandler�
SimpleHandler�BaseCGIHandler�
CGIHandler�
IISCGIHandler� read_environ)ZMonZTueZWedZThuZFriZSatZSun)
NZJanZFebZMarZAprZMayZJunZJulZAugZSepZOctZNovZDecc
C s: t �| �\ }}}}}}}}} dt| |t| ||||f S )Nz#%s, %02d %3s %4d %02d:%02d:%02d GMT)�time�gmtime� _weekdayname�
_monthname)
Z timestampZyearZmonthZdayZhhZmmZssZwd�y�z� r �7/opt/alt/python310/lib64/python3.10/wsgiref/handlers.py�format_date_time s �r >
Z CONTENT_TYPE� PATH_INFOZCONTENT_LENGTHZ REMOTE_USERZREQUEST_METHODZHTTPS� SCRIPT_NAMEZ AUTH_TYPEZ QUERY_STRINGZ REMOTE_IDENTc C s6 t | �p| �d�p| �d�p| �d�ot| dd � �S )NZHTTP_ZSSL_Z REDIRECT_� )� _is_request�
startswith�_needs_transcode)�kr r r r s �r c C s� t �� } d}zd�d|� W n ty d}Y nw i }tj�� D ]S\}}t|�rqt jdkrhtj� dd��
� }|� d�rF|�d�� d�}n+|� d �rLn%|� d
�r^d |v r^|�d�� d�}n|�| d�� d�}n |�| |�� d�}|||< q"|S ) N�surrogateescape� zutf-8�replaceZwin32�SERVER_SOFTWAREzmicrosoft-iis/�
iso-8859-1zapache/z simplehttp/zpython/3)
�sys�getfilesystemencoding�encode� LookupError�os�environ�itemsr �platform�get�lowerr �decode)�encZescr' r �vZsoftwarer r r r " s2 �
�
r c @ s e Zd Z dZdZdZdZdZdZdZ e
� Z e Z
eZdZdZdgZdZd ZZdZdZd Zd
d � Zd d
� Zdd� Zdd� Z dd� Z dd� Z d:dd�Z dd� Z dd� Z!d d � Z"d d � Z#d d!� Z$d"d#� Z%d$d%� Z&d&d'� Z'd(d)� Z(d*d+� Z)d,d-� Z*d.d/� Z+d0d1� Z,d2d3� Z-d4d5� Z.d6d7� Z/d8d9� Z0dS );r )r r TFz1.0Nz500 Internal Server Error)z Content-Typez
text/plains; A server error occurred. Please contact the administrator.r c
C sj z| � � || j| j�| _| �� W d S tttfy! Y d S z| �� W Y d S | � � � �N)
�
setup_environr' �start_response�result�finish_response�ConnectionAbortedError�BrokenPipeError�ConnectionResetError� handle_error�close)�selfZ applicationr r r �run� s zBaseHandler.runc C s� | j �� }| _| �� | �� |d< | �� |d< | j|d< | j|d< | �� |d< | j |d< | j
|d< | j d ur=| j |d< | j rL| j
rN|�d | j
� d S d S d S )
Nz
wsgi.inputz wsgi.errorsz wsgi.versionz
wsgi.run_oncezwsgi.url_schemezwsgi.multithreadzwsgi.multiprocesszwsgi.file_wrapperr )�
os_environ�copyr' � add_cgi_vars� get_stdin�
get_stderr� wsgi_version�
wsgi_run_once�
get_scheme�wsgi_multithread�wsgi_multiprocess�wsgi_file_wrapper�
origin_server�server_software�
setdefault)r9 �envr r r r0 � s
�zBaseHandler.setup_environc C s` z| � � r
| �� s| jD ]}| �|� q
| �� W n t| jd�r)| j�� � | �� d S )Nr8 )�result_is_file�sendfiler2 �write�finish_content�hasattrr8 �r9 �datar r r r3 � s
�
zBaseHandler.finish_responsec C s t | j�S r/ )r r' �r9 r r r rB � s
zBaseHandler.get_schemec
C sL zt | j�}W n
tttfy Y d S w |dkr$t| j�| jd< d S d S )Nr �Content-Length)�lenr2 � TypeError�AttributeError�NotImplementedError�str�
bytes_sent�headers)r9 Zblocksr r r �set_content_length� s ��z BaseHandler.set_content_lengthc C s d| j vr | �� d S d S )NrR )rY rZ rQ r r r �cleanup_headers� s
�zBaseHandler.cleanup_headersc C sn |rz| j r|d |d ��|d ��W d }n d }w | jd ur$td��|| _| �|�| _| �|d�} | jS )Nr r � zHeaders already set!ZStatus)� headers_sent�with_tracebackrY �AssertionError�status�
headers_class�_convert_string_typerL )r9 r` rY �exc_info�name�valr r r r1 � s �
zBaseHandler.start_responsec C s& t |�tu r |S td�|t|����)Nz!{0} must be of type str (got {1}))�typerW r_ �format�repr)r9 �value�titler r r rb � s �z BaseHandler._convert_string_typec C s� | j rD| �� r>| �d| j| jf �d�� d| jvr)| �dtt�� � �d�� | j r@d| jvrB| �d| j �d�� d S d S d S d S | �d| j �d�� d S )Nz HTTP/%s %s
r! ZDatez
Date: %s
ZServerz Server: %s
z Status: %s
)
rF �client_is_modern�_write� http_versionr` r$ rY r r
rG rQ r r r �
send_preamble s
��zBaseHandler.send_preamblec C sR | j std��| jst|�| _| �� n | jt|�7 _| �|� | �� d S )Nz write() before start_response())r` r_ r] rS rX � send_headersrl �_flushrO r r r rL s
zBaseHandler.writec C s dS )NFr rQ r r r rK ) s zBaseHandler.sendfilec C s( | j s| j�dd� | �� d S d S )NrR �0)r] rY rH ro rQ r r r rM > s
zBaseHandler.finish_contentc C s� z5t | jd�r"| j�� W d | _ | _ | _| _d| _d| _d S W d | _ | _ | _| _d| _d| _d S d | _ | _ | _| _d| _d| _w )Nr8 r F)rN r2 r8 rY r` r' rX r] rQ r r r r8 H s ��zBaseHandler.closec C s> | � � d| _| jr| �� r | �� | �t| j�� d S d S )NT)r[ r] rF rk rn rl �bytesrY rQ r r r ro U s �zBaseHandler.send_headersc C s | j }|d uo
t| j|�S r/ )rE �
isinstancer2 )r9 �wrapperr r r rJ ^ s zBaseHandler.result_is_filec C s | j d �� dkS )NZSERVER_PROTOCOLzHTTP/0.9)r' �upperrQ r r r rk d s z BaseHandler.client_is_modernc C sN z"ddl m} | �� }||d |d |d | j|� |�� W d }d S d }w )Nr )�print_exceptionr r\ )� tracebackrv r? �traceback_limit�flush)r9 rc rv �stderrr r r �
log_exceptioni s �
zBaseHandler.log_exceptionc C s8 | � t�� � | js| �| j| j�| _| �� d S d S r/ ) r{ r" rc r] � error_outputr' r1 r2 r3 rQ r r r r7 y s �zBaseHandler.handle_errorc C s& || j | jd d � t�� � | jgS r/ )� error_status�
error_headersr" rc �
error_body)r9 r' r1 r r r r| � s zBaseHandler.error_outputc C � t �r/ �rV rO r r r rl � s zBaseHandler._writec C r� r/ r� rQ r r r rp � s zBaseHandler._flushc C r� r/ r� rQ r r r r> � � zBaseHandler.get_stdinc C r� r/ r� rQ r r r r? � r� zBaseHandler.get_stderrc C r� r/ r� rQ r r r r= � r� zBaseHandler.add_cgi_varsr/ )1�__name__�
__module__� __qualname__r@ rC rD rA rF rm rG r r; r rE r ra rx r} r~ r r` r2 r] rY rX r: r0 r3 rB rZ r[ r1 rb rn rL rK rM r8 ro rJ rk r{ r7 r| rl rp r> r? r= r r r r r ^ sX
r c @ sB e Zd Z ddd�Zdd� Zdd� Zd d
� Zd d � Zd
d� ZdS )r TFc C s( || _ || _|| _|| _|| _|| _d S r/ )�stdin�stdoutrz �base_envrC rD )r9 r� r� rz r' � multithread� multiprocessr r r �__init__� s
zSimpleHandler.__init__c C � | j S r/ )r� rQ r r r r> � � zSimpleHandler.get_stdinc C r� r/ )rz rQ r r r r? � r� zSimpleHandler.get_stderrc C s | j �| j� d S r/ )r' �updater� rQ r r r r= � s zSimpleHandler.add_cgi_varsc C s^ | j �|�}|d u s|t|�krd S ddlm} |dt� ||d � }|s(d S | j �|�}q )Nr )�warnz9SimpleHandler.stdout.write() should not do partial writes)r� rL rS �warningsr� �DeprecationWarning)r9 rP r2 r� r r r rl � s � �zSimpleHandler._writec C s | j �� | j j| _d S r/ )r� ry rp rQ r r r rp � s
zSimpleHandler._flushN)TF) r� r� r� r� r> r? r= rl rp r r r r r � s
�
r c @ s e Zd Z dZdS )r FN)r� r� r� rF r r r r r � s r c @ � e Zd Z dZi Zdd� ZdS )r
Tc C s( t j| tjjtjjtjt� ddd� d S )NFT�r� r� )r r� r" r� �bufferr� rz r rQ r r r r� s
�zCGIHandler.__init__N�r� r� r� rA r; r� r r r r r
� s
r
c @ r� )r Tc C sj t � }|�dd�}|�dd�}|d �|d �r"|t|�d � |d< tj| tjjtj jtj
|ddd� d S )Nr r r �/FTr� ) r r* r rS r r� r" r� r� r� rz )r9 r' �pathZscriptr r r r� 2 s
�zIISCGIHandler.__init__Nr� r r r r r s
r )�utilr r r rY r r" r& r
�__all__r r r � __contains__r r r r r r r
r r r r r �<module> s( �< V2 __pycache__/simple_server.cpython-310.opt-1.pyc 0000644 00000012312 15154351672 0015303 0 ustar 00 o
���h3 � @ s4 d Z ddlmZmZ ddlZddlZddlmZ ddl m
Z
dZ g d�Z de Z
e
� d ej�� d Ze
d
e ZG d d � d e�ZG d
d� de�ZG dd� de�Zdd� Zeefdd�Zedkr�edde��'Zej�� Ze ded ded d� ddl Z e � d � e� � W d � dS 1 s�w Y dS dS ) a! BaseHTTPServer that implements the Python WSGI protocol (PEP 3333)
This is both an example of how WSGI can be implemented, and a basis for running
simple web applications on a local machine, such as might be done when testing
or debugging an application. It has not been reviewed for security issues,
however, and we strongly recommend that you use a "real" web server for
production use.
For example usage, see the 'if __name__=="__main__"' block at the end of the
module. See also the BaseHTTPServer module docs for other API information.
� )�BaseHTTPRequestHandler�
HTTPServerN)�
SimpleHandler)�python_implementationz0.2)�
WSGIServer�WSGIRequestHandler�demo_app� make_server� WSGIServer/�/� c @ s e Zd ZeZdd� ZdS )�
ServerHandlerc C s< z| j �| j�dd�d | j� W t�| � d S t�| � w )Nr � r )�request_handlerZ log_requestZstatus�splitZ
bytes_sentr �close��self� r �</opt/alt/python310/lib64/python3.10/wsgiref/simple_server.pyr s
�zServerHandler.closeN)�__name__�
__module__� __qualname__�software_versionZserver_softwarer r r r r r
s r
c @ s4 e Zd ZdZdZdd� Zdd� Zdd� Zd d
� ZdS ) r z7BaseHTTPServer that implements the Python WSGI protocolNc C s t �| � | �� dS )z.Override server_bind to store the server name.N)r � server_bind�
setup_environr r r r r 0 s
zWSGIServer.server_bindc C sF i }| _ | j|d< d|d< t| j�|d< d|d< d|d< d|d< d S ) NZ SERVER_NAMEzCGI/1.1ZGATEWAY_INTERFACEZ SERVER_PORT� � REMOTE_HOST�CONTENT_LENGTHZ SCRIPT_NAME)� base_environZ server_name�strZ server_port)r �envr r r r 5 s
zWSGIServer.setup_environc C s | j S �N�� applicationr r r r �get_app? � zWSGIServer.get_appc C s
|| _ d S r" r# )r r$ r r r �set_appB s
zWSGIServer.set_app) r r r �__doc__r$ r r r% r' r r r r r * s
r c @ s, e Zd Zde Zdd� Zdd� Zdd� ZdS ) r r
c C sL | j j�� }| j|d< | j|d< | j|d< d| jv r$| j�dd�\}}n| jd}}tj �
|d�|d< ||d < | � � }|| j d
krF||d < | j d
|d < | j
�d
�d u r]| j
�� |d< n| j
d
|d< | j
�d�}|rp||d< | j
�� D ].\}}|�dd��� }|�� }||v r�qud| |v r�|d| d| 7 < qu||d| < qu|S )NZSERVER_PROTOCOLZSERVER_SOFTWAREZREQUEST_METHOD�?r r z
iso-8859-1Z PATH_INFOZ QUERY_STRINGr r Z REMOTE_ADDRz content-typeZ CONTENT_TYPEzcontent-lengthr �-�_ZHTTP_�,)�serverr �copy�request_version�server_version�command�pathr �urllib�parseZunquoteZaddress_stringZclient_addressZheaders�getZget_content_type�items�replace�upper�strip)r r! r2 Zquery�hostZlength�k�vr r r � get_environK s6
z WSGIRequestHandler.get_environc C s t jS r" )�sys�stderrr r r r �
get_stderrp r& z WSGIRequestHandler.get_stderrc C s� | j �d�| _t| j�dkr d| _d| _d| _| �d� dS | �� s$dS t | j | j
| � � | � � dd�}| |_
|�| j�� � dS )z Handle a single HTTP requesti i r i� NF)Z multithread)Zrfile�readlineZraw_requestline�lenZ requestliner/ r1 Z
send_errorZ
parse_requestr
Zwfiler@ r= r �runr- r% )r Zhandlerr r r �handles s
�zWSGIRequestHandler.handleN)r r r � __version__r0 r= r@ rD r r r r r G s
% r c C sr ddl m} |� }td|d� t|d� t| �� �}|D ]\}}t|dt|�|d� q |ddg� |�� �d�gS ) Nr )�StringIOz Hello world!)�file�=z200 OK)z Content-Typeztext/plain; charset=utf-8zutf-8)�iorF �print�sortedr6 �repr�getvalue�encode)�environZstart_responserF �stdout�hr; r< r r r r � s
r c C s || |f|�}|� |� |S )zACreate a new WSGI server listening on `host` and `port` for `app`)r' )r: �portZappZ server_classZ
handler_classr- r r r r � s
r �__main__r i@ zServing HTTP onrR r z...z http://localhost:8000/xyz?abc) r( Z http.serverr r r> Z urllib.parser3 Zwsgiref.handlersr �platformr rE �__all__r0 �versionr � sys_versionr r
r r r r r ZhttpdZsocketZ getsocknameZsarJ Z
webbrowser�openZhandle_requestr r r r �<module> s4 C
�
"�� __pycache__/headers.cpython-310.pyc 0000644 00000017063 15154351672 0013110 0 ustar 00 o
���hn � @ s2 d Z ddlZe�d�Zd dd�ZG dd� d�ZdS )
z�Manage HTTP Response Headers
Much of this module is red-handedly pilfered from email.message in the stdlib,
so portions are Copyright (C) 2001,2002 Python Software Foundation, and were
written by Barry Warsaw.
� Nz[ \(\)<>@,;:\\"/\[\]\?=]� c C sR |dur't |�dkr'|st�|�r!|�dd��dd�}d| |f S d| |f S | S ) z~Convenience function to format and return a key=value pair.
This will quote the value if needed or if quote is true.
Nr �\z\\�"z\"z%s="%s"z%s=%s)�len� tspecials�search�replace)Zparam�valueZquote� r
�6/opt/alt/python310/lib64/python3.10/wsgiref/headers.py� _formatparam
s r c @ s� e Zd ZdZd%dd�Zdd� Zdd� Zd d
� Zd d � Zd
d� Z dd� Z
dd� Z d%dd�Z dd� Z
dd� Zdd� Zdd � Zd d � Zd d � Zd!d"� Zd#d$� ZdS )&�Headersz,Manage a collection of HTTP response headersNc C sR |d ur|ng }t |�turtd��|| _ |D ]\}}| �|� | �|� qd S )Nz+Headers must be a list of name/value tuples)�type�list� TypeError�_headers�_convert_string_type)�selfZheaders�k�vr
r
r �__init__ s
�zHeaders.__init__c C s" t |�tu r|S td�t|����)zConvert/check value type.z1Header names/values must be of type str (got {0}))r �str�AssertionError�format�repr)r r r
r
r r ) s
�z Headers._convert_string_typec C s
t | j�S )z9Return the total number of headers, including duplicates.)r r �r r
r
r �__len__0 s
zHeaders.__len__c C s& | |= | j �| �|�| �|�f� dS )zSet the value of a header.N)r �appendr )r �name�valr
r
r � __setitem__4 s �zHeaders.__setitem__c s0 | � � �� �� � fdd�| jD �| jdd�< dS )zyDelete all occurrences of a header, if present.
Does *not* raise an exception if the header is missing.
c s g | ] }|d � � � kr|�qS )r ��lower��.0Zkv�r r
r �
<listcomp>@ s z'Headers.__delitem__.<locals>.<listcomp>N�r r" r �r r r
r% r � __delitem__: s "zHeaders.__delitem__c C s
| � |�S )aH Get the first header value for 'name'
Return None if the header is missing instead of raising an exception.
Note that if the header appeared multiple times, the first exactly which
occurrence gets returned is undefined. Use getall() to get all
the values matching a header field name.
��getr( r
r
r � __getitem__B s
zHeaders.__getitem__c C s | � |�duS )z/Return true if the message contains the header.Nr* r( r
r
r � __contains__M s zHeaders.__contains__c s" | � � �� �� � fdd�| jD �S )aq Return a list of all the values for the named field.
These will be sorted in the order they appeared in the original header
list or were added to this instance, and may contain duplicates. Any
fields deleted and re-inserted are always appended to the header list.
If no fields exist with the given name, returns an empty list.
c s$ g | ]}|d � � � kr|d �qS )r r r! r# r% r
r r& [ s $ z#Headers.get_all.<locals>.<listcomp>r' r( r
r% r �get_allR s zHeaders.get_allc C s6 | � |�� �}| jD ]\}}|�� |kr| S q
|S )z:Get the first header value for 'name', or return 'default'r' )r r �defaultr r r
r
r r+ ^ s �z Headers.getc C � dd� | j D �S )a* Return a list of all the header field names.
These will be sorted in the order they appeared in the original header
list, or were added to this instance, and may contain duplicates.
Any fields deleted and re-inserted are always appended to the header
list.
c S s g | ]\}}|�qS r
r
�r$ r r r
r
r r& o � z Headers.keys.<locals>.<listcomp>�r r r
r
r �keysg � z Headers.keysc C r0 )a! Return a list of all header values.
These will be sorted in the order they appeared in the original header
list, or were added to this instance, and may contain duplicates.
Any fields deleted and re-inserted are always appended to the header
list.
c S s g | ]\}}|�qS r
r
r1 r
r
r r& y r2 z"Headers.values.<locals>.<listcomp>r3 r r
r
r �valuesq r5 zHeaders.valuesc C s | j dd� S )a Get all the header fields and values.
These will be sorted in the order they were in the original header
list, or were added to this instance, and may contain duplicates.
Any fields deleted and re-inserted are always appended to the header
list.
Nr3 r r
r
r �items{ s z
Headers.itemsc C s d| j j| jf S )Nz%s(%r))� __class__�__name__r r r
r
r �__repr__� s zHeaders.__repr__c C s d� dd� | jD �ddg �S )zkstr() returns the formatted headers, complete with end line,
suitable for direct HTTP transmission.z
c S s g | ]}d | �qS )z%s: %sr
r# r
r
r r& � r2 z#Headers.__str__.<locals>.<listcomp>� )�joinr r r
r
r �__str__� s zHeaders.__str__c C s t | ��d�S )Nz
iso-8859-1)r �encoder r
r
r � __bytes__� s zHeaders.__bytes__c C s6 | � |�}|du r| j�| �|�| �|�f� |S |S )z�Return first matching header value for 'name', or 'value'
If there is no header named 'name', add a new header with name 'name'
and value 'value'.N)r+ r r r )r r r �resultr
r
r �
setdefault� s
�zHeaders.setdefaultc K s� g }|dur| � |�}|�|� |�� D ](\}}| � |�}|du r+|�|�dd�� q| � |�}|�t|�dd�|�� q| j�| � |�d�|�f� dS )af Extended header setting.
_name is the header field to add. keyword arguments can be used to set
additional parameters for the header field, with underscores converted
to dashes. Normally the parameter will be added as key="value" unless
value is None, in which case only the key will be added.
Example:
h.add_header('content-disposition', 'attachment', filename='bud.gif')
Note that unlike the corresponding 'email.message' method, this does
*not* handle '(charset, language, value)' tuples: all values must be
strings or None.
N�_�-z; )r r r7 r r r r< )r �_nameZ_valueZ_params�partsr r r
r
r �
add_header� s
zHeaders.add_header)N)r9 �
__module__� __qualname__�__doc__r r r r r) r, r- r. r+ r4 r6 r7 r: r= r? rA rF r
r
r
r r
s&
r
)Nr )rI �re�compiler r r
r
r
r
r �<module> s
__pycache__/util.cpython-310.opt-2.pyc 0000644 00000007455 15154351672 0013416 0 ustar 00 o
���h� � @ s` d dl Z g d�ZG dd� d�Zdd� Zdd� Zdd
d �Zd d
� Zdd� Zh d�jZ dd� Z
dS )� N)� FileWrapper� guess_scheme�application_uri� request_uri�shift_path_info�setup_testing_defaultsc @ s0 e Zd Z d dd�Zdd� Zdd� Zdd � Zd
S ) r � c C s& || _ || _t|d�r|j| _d S d S )N�close)�filelike�blksize�hasattrr )�selfr
r � r �3/opt/alt/python310/lib64/python3.10/wsgiref/util.py�__init__ s
�zFileWrapper.__init__c C s2 dd l }|jdtdd� | j�| j�}|r|S t�)Nr zXFileWrapper's __getitem__ method ignores 'key' parameter. Use iterator protocol instead.� )�
stacklevel)�warnings�warn�DeprecationWarningr
�readr �
IndexError)r
�keyr �datar r r � __getitem__ s �zFileWrapper.__getitem__c C s | S �Nr )r
r r r �__iter__! s zFileWrapper.__iter__c C s | j �| j�}|r |S t�r )r
r r �
StopIteration)r
r r r r �__next__$ s zFileWrapper.__next__N)r )�__name__�
__module__� __qualname__r r r r r r r r r s
r c C s | � d�dv r
dS dS )NZHTTPS)ZyesZon�1�https�http)�get)�environr r r r * s r c C s� | d d }ddl m} | �d�r|| d 7 }n)|| d 7 }| d dkr4| d d kr3|d
| d 7 }n| d d krB|d
| d 7 }||| �d �pJd
dd�7 }|S )N�wsgi.url_schemez://r ��quote� HTTP_HOST� SERVER_NAMEr# � SERVER_PORT�443�:�80� SCRIPT_NAME�/�latin1)�encoding)� urllib.parser) r% )r& �urlr) r r r r 2 s
� r Tc C sr t | �}ddlm} || �dd�ddd�}| �d�s$||d d � 7 }n||7 }|r7| �d
�r7|d | d
7 }|S ) Nr r( � PATH_INFO� z/;=,r2 )Zsafer3 r0 � Z QUERY_STRING�?)r r4 r) r% )r& Z
include_queryr5 r) � path_infor r r r F s
r c C s� | � dd�}|s d S |�d�}dd� |dd� D �|dd�< |d }|d= | � dd�}t�|d | �}|�d�r@|d d� }|sK|�d�sK|d7 }|| d< d�|�| d< |d kr\d }|S )
Nr6 r7 r1 c S s g | ]
}|r|d kr|�qS )�.r )�.0�pr r r �
<listcomp>e s z#shift_path_info.<locals>.<listcomp>r8 ���r0 r; )r% �split� posixpath�normpath�endswith�join)r& r: �
path_parts�nameZ script_namer r r r S s&
r c C s | � dd� | � dd� | � d| d � | � dd� d| vr/d | vr/| � dd
� | � d d � | � d d
� | � dd� | � dd� | � dd� ddlm}m} | � d|� � | � d|� � | � dt| �� | d dkrs| � dd� d S | d dkr�| � dd� d S d S )Nr+ z 127.0.0.1ZSERVER_PROTOCOLzHTTP/1.0r* ZREQUEST_METHODZGETr0 r6 r7 r1 z wsgi.version)r8 r z
wsgi.run_oncer zwsgi.multithreadzwsgi.multiprocess)�StringIO�BytesIOz
wsgi.inputz wsgi.errorsr' r$ r, r/ r# r- )�
setdefault�iorG rH r )r& rG rH r r r r | s* �r > zproxy-authenticateZupgradeztransfer-encodingz
keep-alive�teZtrailerszproxy-authorizationZ
connectionc C s t | �� �S r )�_hoppish�lower)Z header_namer r r �
is_hop_by_hop� s rN )T) rA �__all__r r r r r r � __contains__rL rN r r r r �<module> s
)(� __pycache__/handlers.cpython-310.opt-1.pyc 0000644 00000037126 15154351672 0014236 0 ustar 00 o
���h�T � @ s� d Z ddlmZmZmZ ddlmZ ddlZddlZddl Z g d�Z
g d�Z g d�Z d d
� Z
h d �jZd d
� Zdd� ZG dd� d�ZG dd� de�ZG dd� de�ZG dd� de�ZG dd� de�ZdS )z/Base classes for server/gateway implementations� )� FileWrapper� guess_scheme�
is_hop_by_hop)�Headers� N)� BaseHandler�
SimpleHandler�BaseCGIHandler�
CGIHandler�
IISCGIHandler� read_environ)ZMonZTueZWedZThuZFriZSatZSun)
NZJanZFebZMarZAprZMayZJunZJulZAugZSepZOctZNovZDecc
C s: t �| �\ }}}}}}}}} dt| |t| ||||f S )Nz#%s, %02d %3s %4d %02d:%02d:%02d GMT)�time�gmtime� _weekdayname�
_monthname)
Z timestampZyearZmonthZdayZhhZmmZssZwd�y�z� r �7/opt/alt/python310/lib64/python3.10/wsgiref/handlers.py�format_date_time s �r >
Z CONTENT_TYPE� PATH_INFOZCONTENT_LENGTHZ REMOTE_USERZREQUEST_METHODZHTTPS� SCRIPT_NAMEZ AUTH_TYPEZ QUERY_STRINGZ REMOTE_IDENTc C s6 t | �p| �d�p| �d�p| �d�ot| dd � �S )NZHTTP_ZSSL_Z REDIRECT_� )� _is_request�
startswith�_needs_transcode)�kr r r r s �r c C s� t �� } d}zd�d|� W n ty d}Y nw i }tj�� D ]S\}}t|�rpt jdkrgtj� dd��
� }|� d�rE|�d�� d�}n+|� d �rKn%|� d
�r]d |v r]|�d�� d�}n|�| d�� d�}n |�| |�� d�}|||< q!|S ) z'Read environment, fixing HTTP variables�surrogateescape� zutf-8�replaceZwin32�SERVER_SOFTWAREzmicrosoft-iis/�
iso-8859-1zapache/z simplehttp/zpython/3)
�sys�getfilesystemencoding�encode� LookupError�os�environ�itemsr �platform�get�lowerr �decode)�encZescr' r �vZsoftwarer r r r " s0 �
�
r c @ s" e Zd ZdZdZdZdZdZdZdZ dZ
e � Z e
ZeZdZdZdgZd Zd ZZdZdZd
Zd d � Zd
d� Zdd� Z dd� Z dd� Z dd� Z d;dd�Z dd� Z!dd � Z"d d � Z#d d � Z$d!d"� Z%d#d$� Z&d%d&� Z'd'd(� Z(d)d*� Z)d+d,� Z*d-d.� Z+d/d0� Z,d1d2� Z-d3d4� Z.d5d6� Z/d7d8� Z0d9d:� Z1dS )<r z+Manage the invocation of a WSGI application)r r TFz1.0Nz500 Internal Server Error)z Content-Typez
text/plains; A server error occurred. Please contact the administrator.r c
C sh z| � � || j| j�| _| �� W dS tttfy Y dS z| �� W Y dS | � � � )zInvoke the applicationN)
�
setup_environr' �start_response�result�finish_response�ConnectionAbortedError�BrokenPipeError�ConnectionResetError� handle_error�close)�selfZ applicationr r r �run� s zBaseHandler.runc C s� | j �� }| _| �� | �� |d< | �� |d< | j|d< | j|d< | �� |d< | j |d< | j
|d< | j dur<| j |d < | j rK| j
rM|�d
| j
� dS dS dS ) z&Set up the environment for one requestz
wsgi.inputz wsgi.errorsz wsgi.versionz
wsgi.run_oncezwsgi.url_schemezwsgi.multithreadzwsgi.multiprocessNzwsgi.file_wrapperr )�
os_environ�copyr' � add_cgi_vars� get_stdin�
get_stderr� wsgi_version�
wsgi_run_once�
get_scheme�wsgi_multithread�wsgi_multiprocess�wsgi_file_wrapper�
origin_server�server_software�
setdefault)r8 �envr r r r/ � s
�zBaseHandler.setup_environc C s^ z| � � r | �� s| jD ]}| �|� q | �� W n t| jd�r(| j�� � | �� dS )a> Send any iterable data, then close self and the iterable
Subclasses intended for use in asynchronous servers will
want to redefine this method, such that it sets up callbacks
in the event loop to iterate over the data, and to call
'self.close()' once the response is finished.
r7 N)�result_is_file�sendfiler1 �write�finish_content�hasattrr7 �r8 �datar r r r2 � s
�
zBaseHandler.finish_responsec C s
t | j�S )z Return the URL scheme being used)r r' �r8 r r r rA � s
zBaseHandler.get_schemec
C sJ zt | j�}W n
tttfy Y dS w |dkr#t| j�| jd< dS dS )z@Compute Content-Length or switch to chunked encoding if possibler �Content-LengthN)�lenr1 � TypeError�AttributeError�NotImplementedError�str�
bytes_sent�headers)r8 Zblocksr r r �set_content_length� s ��z BaseHandler.set_content_lengthc C s d| j vr | �� dS dS )zqMake any necessary header changes or defaults
Subclasses can extend this to add other defaults.
rQ N)rX rY rP r r r �cleanup_headers� s
�zBaseHandler.cleanup_headersc C sl |rz| j r|d |d ��|d ��W d}n d}w | jdur#td��|| _| �|�| _| �|d�} | jS )z4'start_response()' callable as specified by PEP 3333r r � NzHeaders already set!ZStatus)� headers_sent�with_tracebackrX �AssertionError�status�
headers_class�_convert_string_typerK )r8 r_ rX �exc_info�name�valr r r r0 � s �
zBaseHandler.start_responsec C s$ t |�tu r|S td�|t|����)zConvert/check value type.z!{0} must be of type str (got {1}))�typerV r^ �format�repr)r8 �value�titler r r ra � s
�z BaseHandler._convert_string_typec C s� | j rC| �� r=| �d| j| jf �d�� d| jvr(| �dtt�� � �d�� | j r?d| jvrA| �d| j �d�� dS dS dS dS | �d| j �d�� dS ) z6Transmit version/status/date/server, via self._write()z HTTP/%s %s
r! ZDatez
Date: %s
ZServerz Server: %s
z Status: %s
N)
rE �client_is_modern�_write� http_versionr_ r$ rX r r
rF rP r r r �
send_preamble s
��zBaseHandler.send_preamblec C sP | j std��| jst|�| _| �� n | jt|�7 _| �|� | �� dS )z+'write()' callable as specified by PEP 3333z write() before start_response()N)r_ r^ r\ rR rW � send_headersrk �_flushrN r r r rK s
zBaseHandler.writec C s dS )a Platform-specific file transmission
Override this method in subclasses to support platform-specific
file transmission. It is only called if the application's
return iterable ('self.result') is an instance of
'self.wsgi_file_wrapper'.
This method should return a true value if it was able to actually
transmit the wrapped file-like object using a platform-specific
approach. It should return a false value if normal iteration
should be used instead. An exception can be raised to indicate
that transmission was attempted, but failed.
NOTE: this method should call 'self.send_headers()' if
'self.headers_sent' is false and it is going to attempt direct
transmission of the file.
Fr rP r r r rJ ) s zBaseHandler.sendfilec C s& | j s| j�dd� | �� dS dS )z.Ensure headers and content have both been sentrQ �0N)r\ rX rG rn rP r r r rL > s zBaseHandler.finish_contentc C s� z5t | jd�r!| j�� W d | _ | _ | _| _d| _d| _dS W d | _ | _ | _| _d| _d| _dS d | _ | _ | _| _d| _d| _w )z�Close the iterable (if needed) and reset all instance vars
Subclasses may want to also drop the client connection.
r7 Nr F)rM r1 r7 rX r_ r' rW r\ rP r r r r7 H s ��zBaseHandler.closec C s< | � � d| _| jr| �� r | �� | �t| j�� dS dS )z1Transmit headers to the client, via self._write()TN)rZ r\ rE rj rm rk �bytesrX rP r r r rn U s �zBaseHandler.send_headersc C s | j }|duo t| j|�S )z@True if 'self.result' is an instance of 'self.wsgi_file_wrapper'N)rD �
isinstancer1 )r8 �wrapperr r r rI ^ s zBaseHandler.result_is_filec C s | j d �� dkS )z,True if client can accept status and headersZSERVER_PROTOCOLzHTTP/0.9)r' �upperrP r r r rj d s z BaseHandler.client_is_modernc C sL z"ddl m} | �� }||d |d |d | j|� |�� W d}dS d}w )z�Log the 'exc_info' tuple in the server log
Subclasses may override to retarget the output or change its format.
r )�print_exceptionr r[ N)� tracebackru r> �traceback_limit�flush)r8 rb ru �stderrr r r �
log_exceptioni s �
zBaseHandler.log_exceptionc C s6 | � t�� � | js| �| j| j�| _| �� dS dS )z>Log current error, and send error output to client if possibleN) rz r" rb r\ � error_outputr' r0 r1 r2 rP r r r r6 y s
�zBaseHandler.handle_errorc C s$ || j | jdd� t�� � | jgS )aZ WSGI mini-app to create error output
By default, this just uses the 'error_status', 'error_headers',
and 'error_body' attributes to generate an output page. It can
be overridden in a subclass to dynamically generate diagnostics,
choose an appropriate message for the user's preferred language, etc.
Note, however, that it's not recommended from a security perspective to
spit out diagnostics to any old user; ideally, you should have to do
something special to enable diagnostic output, which is why we don't
include any here!
N)� error_status�
error_headersr" rb �
error_body)r8 r' r0 r r r r{ � s
zBaseHandler.error_outputc C � t �)a Override in subclass to buffer data for send to client
It's okay if this method actually transmits the data; BaseHandler
just separates write and flush operations for greater efficiency
when the underlying system actually has such a distinction.
�rU rN r r r rk � s zBaseHandler._writec C r )z�Override in subclass to force sending of recent '_write()' calls
It's okay if this method is a no-op (i.e., if '_write()' actually
sends the data.
r� rP r r r ro � s zBaseHandler._flushc C r )z4Override in subclass to return suitable 'wsgi.input'r� rP r r r r= � � zBaseHandler.get_stdinc C r )z5Override in subclass to return suitable 'wsgi.errors'r� rP r r r r> � r� zBaseHandler.get_stderrc C r )z>Override in subclass to insert CGI variables in 'self.environ'r� rP r r r r< � r� zBaseHandler.add_cgi_vars�N)2�__name__�
__module__� __qualname__�__doc__r? rB rC r@ rE rl rF r r: r rD r r` rw r| r} r~ r_ r1 r\ rX rW r9 r/ r2 rA rY rZ r0 ra rm rK rJ rL r7 rn rI rj rz r6 r{ rk ro r= r> r< r r r r r ^ sX
r c @ sD e Zd ZdZ ddd�Zdd� Zdd � Zd
d � Zd d
� Zdd� Z dS )r aq Handler that's just initialized with streams, environment, etc.
This handler subclass is intended for synchronous HTTP/1.0 origin servers,
and handles sending the entire response output, given the correct inputs.
Usage::
handler = SimpleHandler(
inp,out,err,env, multithread=False, multiprocess=True
)
handler.run(app)TFc C s( || _ || _|| _|| _|| _|| _d S r� )�stdin�stdoutry �base_envrB rC )r8 r� r� ry r' � multithread� multiprocessr r r �__init__� s
zSimpleHandler.__init__c C � | j S r� )r� rP r r r r= � � zSimpleHandler.get_stdinc C r� r� )ry rP r r r r> � r� zSimpleHandler.get_stderrc C s | j �| j� d S r� )r' �updater� rP r r r r< � s zSimpleHandler.add_cgi_varsc C s^ | j �|�}|d u s|t|�krd S ddlm} |dt� ||d � }|s(d S | j �|�}q )Nr )�warnz9SimpleHandler.stdout.write() should not do partial writes)r� rK rR �warningsr� �DeprecationWarning)r8 rO r1 r� r r r rk � s � �zSimpleHandler._writec C s | j �� | j j| _d S r� )r� rx ro rP r r r ro � s
zSimpleHandler._flushN)TF)
r� r� r� r� r� r= r> r< rk ro r r r r r � s
�
r c @ s e Zd ZdZdZdS )r a� CGI-like systems using input/output/error streams and environ mapping
Usage::
handler = BaseCGIHandler(inp,out,err,env)
handler.run(app)
This handler class is useful for gateway protocols like ReadyExec and
FastCGI, that have usable input/output/error streams and an environment
mapping. It's also the base class for CGIHandler, which just uses
sys.stdin, os.environ, and so on.
The constructor also takes keyword arguments 'multithread' and
'multiprocess' (defaulting to 'True' and 'False' respectively) to control
the configuration sent to the application. It sets 'origin_server' to
False (to enable CGI-like output), and assumes that 'wsgi.run_once' is
False.
FN)r� r� r� r� rE r r r r r � s r c @ � e Zd ZdZdZi Zdd� ZdS )r
a� CGI-based invocation via sys.stdin/stdout/stderr and os.environ
Usage::
CGIHandler().run(app)
The difference between this class and BaseCGIHandler is that it always
uses 'wsgi.run_once' of 'True', 'wsgi.multithread' of 'False', and
'wsgi.multiprocess' of 'True'. It does not take any initialization
parameters, but always uses 'sys.stdin', 'os.environ', and friends.
If you need to override any of these parameters, use BaseCGIHandler
instead.
Tc C s( t j| tjjtjjtjt� ddd� d S )NFT�r� r� )r r� r" r� �bufferr� ry r rP r r r r� s
�zCGIHandler.__init__N�r� r� r� r� r@ r: r� r r r r r
� s
r
c @ r� )r a CGI-based invocation with workaround for IIS path bug
This handler should be used in preference to CGIHandler when deploying on
Microsoft IIS without having set the config allowPathInfo option (IIS>=7)
or metabase allowPathInfoForScriptMappings (IIS<7).
Tc C sj t � }|�dd�}|�dd�}|d �|d �r"|t|�d � |d< tj| tjjtj jtj
|ddd� d S )Nr r r �/FTr� ) r r* r rR r r� r" r� r� r� ry )r8 r' �pathZscriptr r r r� 2 s
�zIISCGIHandler.__init__Nr� r r r r r s
r )r� �utilr r r rX r r" r& r
�__all__r r r � __contains__r r r r r r r
r r r r r �<module> s( �< V2 __pycache__/validate.cpython-310.pyc 0000644 00000034422 15154351672 0013264 0 ustar 00 o
���h�: � @ s� d Z dgZddlZddlZddlZe�d�Ze�d�ZG dd� de�Z dd � Z
d
d � Z d d� Z G d
d� d�Z
G dd� d�ZG dd� d�ZG dd� d�ZG dd� d�Zdd� Zdd� Zdd � Zd d � Zd d � Zd!d"� Zd#d$� Zd%d&� ZdS )'a&
Middleware to check for obedience to the WSGI specification.
Some of the things this checks:
* Signature of the application and start_response (including that
keyword arguments are not used).
* Environment checks:
- Environment is a dictionary (and not a subclass).
- That all the required keys are in the environment: REQUEST_METHOD,
SERVER_NAME, SERVER_PORT, wsgi.version, wsgi.input, wsgi.errors,
wsgi.multithread, wsgi.multiprocess, wsgi.run_once
- That HTTP_CONTENT_TYPE and HTTP_CONTENT_LENGTH are not in the
environment (these headers should appear as CONTENT_LENGTH and
CONTENT_TYPE).
- Warns if QUERY_STRING is missing, as the cgi module acts
unpredictably in that case.
- That CGI-style variables (that don't contain a .) have
(non-unicode) string values
- That wsgi.version is a tuple
- That wsgi.url_scheme is 'http' or 'https' (@@: is this too
restrictive?)
- Warns if the REQUEST_METHOD is not known (@@: probably too
restrictive).
- That SCRIPT_NAME and PATH_INFO are empty or start with /
- That at least one of SCRIPT_NAME or PATH_INFO are set.
- That CONTENT_LENGTH is a positive integer.
- That SCRIPT_NAME is not '/' (it should be '', and PATH_INFO should
be '/').
- That wsgi.input has the methods read, readline, readlines, and
__iter__
- That wsgi.errors has the methods flush, write, writelines
* The status is a string, contains a space, starts with an integer,
and that integer is in range (> 100).
* That the headers is a list (not a subclass, not another kind of
sequence).
* That the items of the headers are tuples of strings.
* That there is no 'status' header (that is used in CGI, but not in
WSGI).
* That the headers don't contain newlines or colons, end in _ or -, or
contain characters codes below 037.
* That Content-Type is given if there is content (CGI often has a
default content type, but WSGI does not).
* That no Content-Type is given when there is no content (@@: is this
too restrictive?)
* That the exc_info argument to start_response is a tuple or None.
* That all calls to the writer are with strings, and no other methods
on the writer are accessed.
* That wsgi.input is used properly:
- .read() is called with exactly one argument
- That it returns a string
- That readline, readlines, and __iter__ return strings
- That .close() is not called
- No other methods are provided
* That wsgi.errors is used properly:
- .write() and .writelines() is called with a string
- That .close() is not called, and no other methods are provided.
* The response iterator:
- That it is not a string (it should be a list of a single string; a
string will work, but perform horribly).
- That .__next__() returns a string
- That the iterator is not iterated over until start_response has
been called (that can signal either a server or application
error).
- That .close() is called (doesn't raise exception, only prints to
sys.stderr, because we only know it isn't called when the object
is garbage collected).
� validator� Nz^[a-zA-Z][a-zA-Z0-9\-_]*$z [\000-\037]c @ s e Zd ZdZdS )� WSGIWarningz:
Raised in response to WSGI-spec-related warnings
N)�__name__�
__module__� __qualname__�__doc__� r r �7/opt/alt/python310/lib64/python3.10/wsgiref/validate.pyr y s r c G s | st |� �d S �N)�AssertionError)Zcond�argsr r r �assert_~ s �r
c C s$ t | �tu r| S td�|t| ����)Nz!{0} must be of type str (got {1}))�type�strr �format�repr)�value�titler r r �check_string_type� s
�r c s � fdd�}|S )a�
When applied between a WSGI server and a WSGI application, this
middleware will check for WSGI compliance on a number of levels.
This middleware does not modify the request or response in any
way, but will raise an AssertionError if anything seems off
(except for a failure to close the application iterator, which
will be printed to stderr -- there's no way to raise an exception
at that point).
c s� t t| �dkd� t | d� | \}� t|� g �� �fdd�}t|d �|d< t|d �|d< �||�}t |d uo=|dkd � t|� t|��S )
N� zTwo arguments required� No keyword arguments allowedc s� t t| �dkp t| �dkd| f � t | d� | d }| d }t| �dkr+| d }nd }t|� t|� t||� t|� ��d � t� | � �S )Nr � z Invalid number of arguments: %sr r � )r
�len� check_status�
check_headers�check_content_type�check_exc_info�append� WriteWrapper)r �kw�status�headers�exc_info�Zstart_responseZstart_response_startedr r �start_response_wrapper� s �
z;validator.<locals>.lint_app.<locals>.start_response_wrapper�
wsgi.input� wsgi.errorsFz>The application must return an iterator, if only an empty list)r
r �
check_environ� InputWrapper� ErrorWrapper�check_iterator�IteratorWrapper)r r �environr% �iterator�� applicationr$ r �lint_app� s
�
zvalidator.<locals>.lint_appr )r0 r1 r r/ r r � s )c @ s< e Zd Zdd� Zdd� Zdd� Zdd� Zd d
� Zd d � Zd
S )r) c C �
|| _ d S r
)�input)�self�
wsgi_inputr r r �__init__� �
zInputWrapper.__init__c G s0 t t|�dk� | jj|� }t t|�tu � |S �Nr )r
r r3 �readr �bytes�r4 r �vr r r r9 � � zInputWrapper.readc G s0 t t|�dk� | jj|� }t t|�tu � |S r8 )r
r r3 �readliner r: r; r r r r> � r= zInputWrapper.readlinec G sJ t t|�dk� | jj|� }t t|�tu � |D ]
}t t|�tu � q|S r8 )r
r r3 � readlinesr �listr: )r4 r �lines�liner r r r? � s zInputWrapper.readlinesc c s � | � � }|s
d S |V qr
)r> )r4 rB r r r �__iter__� s ��zInputWrapper.__iter__c C � t dd� d S )Nr z input.close() must not be called�r
�r4 r r r �close� � zInputWrapper.closeN) r r r r6 r9 r> r? rC rG r r r r r) � s r) c @ �4 e Zd Zdd� Zdd� Zdd� Zdd� Zd d
� Zd S ) r* c C r2 r
)�errors)r4 � wsgi_errorsr r r r6 � r7 zErrorWrapper.__init__c C s t t|�tu � | j�|� d S r
)r
r r rJ �write�r4 �sr r r rL � s zErrorWrapper.writec C s | j �� d S r
)rJ �flushrF r r r rO � rH zErrorWrapper.flushc C s |D ]}| � |� qd S r
)rL )r4 �seqrB r r r �
writelines� s �zErrorWrapper.writelinesc C rD )Nr z!errors.close() must not be calledrE rF r r r rG � rH zErrorWrapper.closeN)r r r r6 rL rO rQ rG r r r r r* � s r* c @ � e Zd Zdd� Zdd� ZdS )r c C r2 r
)�writer)r4 Z wsgi_writerr r r r6 � r7 zWriteWrapper.__init__c C s t t|�tu � | �|� d S r
)r
r r: rS rM r r r �__call__� s zWriteWrapper.__call__N)r r r r6 rT r r r r r � � r c @ rR )�PartialIteratorWrapperc C r2 r
�r. )r4 �
wsgi_iteratorr r r r6 r7 z PartialIteratorWrapper.__init__c C s t | jd �S r
)r, r. rF r r r rC s z PartialIteratorWrapper.__iter__N)r r r r6 rC r r r r rV � rU rV c @ rI ) r, c C s || _ t|�| _d| _|| _d S )NF)�original_iterator�iterr. �closed�check_start_response)r4 rX r\ r r r r6 s
zIteratorWrapper.__init__c C s | S r
r rF r r r rC s zIteratorWrapper.__iter__c C sT t | j d� t| j�}t|�turt dd|f � | jd ur(t | jd� d | _|S )NzIterator read after closedFz$Iterator yielded non-bytestring (%r)zjThe application returns and we started iterating over its body, but start_response has not yet been called)r
r[ �nextr. r r: r\ )r4 r< r r r �__next__ s �
�zIteratorWrapper.__next__c C s$ d| _ t| jd�r| j�� d S d S )NTrG )r[ �hasattrrY rG rF r r r rG s �zIteratorWrapper.closec C s" | j s tj�d� t| j d� d S )Nz/Iterator garbage collected without being closed)r[ �sys�stderrrL r
rF r r r �__del__# s ��zIteratorWrapper.__del__N)r r r r6 rC r^ rG rb r r r r r, s r, c C s� t t| �tu dt| �| f � dD ] }t || v d|f � qdD ]}t || vd||dd � f � q d| vr<t�dt� | �� D ] }d |v rGq@t t| | �tu d
|t| | �| | f � q@t t| d �tu d | d f � t | d
dv d| d
� t | d � t
| d � | d dvr�t�d| d t� t | � d� p�| d � d�d| d � t | � d� p�| d � d�d| d � | � d�r�t t
| d �dkd | d � | � d�s�t d| v d � t | � d�dkd � d S ) Nz:Environment is not of the right type: %r (environment: %r)) �REQUEST_METHODZ SERVER_NAMEZ SERVER_PORT� wsgi.versionr& r' zwsgi.multithreadzwsgi.multiprocessz
wsgi.run_oncez$Environment missing required key: %r)ZHTTP_CONTENT_TYPEZHTTP_CONTENT_LENGTHz8Environment should not have the key: %s (use %s instead)� Z QUERY_STRINGz�QUERY_STRING is not in the WSGI environment; the cgi module will use sys.argv when this variable is missing, so application errors are more likely�.z9Environmental variable %s is not a string: %r (value: %r)rd z#wsgi.version should be a tuple (%r)zwsgi.url_scheme)ZhttpZhttpszwsgi.url_scheme unknown: %rr& r' rc )ZGETZHEADZPOSTZOPTIONSZPATCHZPUTZDELETEZTRACEzUnknown REQUEST_METHOD: %rZ SCRIPT_NAME�/z$SCRIPT_NAME doesn't start with /: %rZ PATH_INFOz"PATH_INFO doesn't start with /: %rZCONTENT_LENGTHr zInvalid CONTENT_LENGTH: %rzgOne of SCRIPT_NAME or PATH_INFO are required (PATH_INFO should at least be '/' if SCRIPT_NAME is empty)zOSCRIPT_NAME cannot be '/'; it should instead be '', and PATH_INFO should be '/')r
r �dict�warnings�warnr �keysr �tuple� check_input� check_errors�get�
startswith�int)r- �keyr r r r( * sx
������ �� �
�
�
�
�
�
��r( c C �& dD ]}t t| |�d| |f � qd S )N)r9 r> r? rC z-wsgi.input (%r) doesn't have the attribute %s�r
r_ )r5 �attrr r r rm k �
���rm c C rs )N)rO rL rQ z.wsgi.errors (%r) doesn't have the attribute %srt )rK ru r r r rn q rv rn c C sz t | d�} | �d d�d }tt|�dkd| � t|�}t|dkd| � t| �dk s1| d d kr;t�d
| t� d S d S ) N�Statusr r r z)Status codes must be three characters: %r�d zStatus code is invalid: %r� � zjThe status string (%r) should be a three-digit integer followed by a single space and a status explanation)r �splitr
r rq ri rj r )r! Z status_codeZ
status_intr r r r w s
����r c C s t t| �tu d| t| �f � | D ]n}t t|�tu d|t|�f � t t|�dk� |\}}t|d�}t|d�}t |�� dkd| � t d|voKd |vd
| � t t�|�d | � t |� d � of|� d
� d| � t
�|�rt dd|t
�|�� d�f � qd S )Nz%Headers (%r) must be of type list: %rz1Individual headers (%r) must be of type tuple: %rr � Header namez Header valuer! zyThe Status header cannot be used; it conflicts with CGI script, and HTTP status is not given through headers (value: %r).�
�:z,Header names may not contain ':' or '\n': %rzBad header name: %r�-�_z#Names may not end in '-' or '_': %rr z#Bad header value: %r (bad char: %r)) r
r r@ rl r r �lower� header_re�search�endswith�bad_header_value_re�group)r" �item�namer r r r r � sB
��
��
����
���r c C s� t | d�} t| �d d�d �}d}|D ] \}}t |d�}|�� dkr0||vr) d S tdd| � q||vr>tdd| � d S d S ) Nrw r r )�� i0 r| z content-typezJContent-Type header found in a %s response, which must not return content.z,No Content-Type header found in headers (%s))r rq r{ r� r
)r! r" �codeZNO_MESSAGE_BODYr� r r r r r � s
���r c C s* t | d u p
t| �tu d| t| �f � d S )Nz exc_info (%r) is not a tuple: %r)r
r rl )r# r r r r � s �r c C s t t| ttf� d� d S )NzwYou should not return a string as your application iterator, instead return a single-item list containing a bytestring.)r
�
isinstancer r: rW r r r r+ � s �r+ )r �__all__�rer` ri �compiler� r� �Warningr r
r r r) r* r rV r, r( rm rn r r r r r+ r r r r �<module> s0 j
7# #A __pycache__/simple_server.cpython-310.pyc 0000644 00000012312 15154351672 0014344 0 ustar 00 o
���h3 � @ s4 d Z ddlmZmZ ddlZddlZddlmZ ddl m
Z
dZ g d�Z de Z
e
� d ej�� d Ze
d
e ZG d d � d e�ZG d
d� de�ZG dd� de�Zdd� Zeefdd�Zedkr�edde��'Zej�� Ze ded ded d� ddl Z e � d � e� � W d � dS 1 s�w Y dS dS ) a! BaseHTTPServer that implements the Python WSGI protocol (PEP 3333)
This is both an example of how WSGI can be implemented, and a basis for running
simple web applications on a local machine, such as might be done when testing
or debugging an application. It has not been reviewed for security issues,
however, and we strongly recommend that you use a "real" web server for
production use.
For example usage, see the 'if __name__=="__main__"' block at the end of the
module. See also the BaseHTTPServer module docs for other API information.
� )�BaseHTTPRequestHandler�
HTTPServerN)�
SimpleHandler)�python_implementationz0.2)�
WSGIServer�WSGIRequestHandler�demo_app� make_server� WSGIServer/�/� c @ s e Zd ZeZdd� ZdS )�
ServerHandlerc C s< z| j �| j�dd�d | j� W t�| � d S t�| � w )Nr � r )�request_handlerZ log_requestZstatus�splitZ
bytes_sentr �close��self� r �</opt/alt/python310/lib64/python3.10/wsgiref/simple_server.pyr s
�zServerHandler.closeN)�__name__�
__module__� __qualname__�software_versionZserver_softwarer r r r r r
s r
c @ s4 e Zd ZdZdZdd� Zdd� Zdd� Zd d
� ZdS ) r z7BaseHTTPServer that implements the Python WSGI protocolNc C s t �| � | �� dS )z.Override server_bind to store the server name.N)r � server_bind�
setup_environr r r r r 0 s
zWSGIServer.server_bindc C sF i }| _ | j|d< d|d< t| j�|d< d|d< d|d< d|d< d S ) NZ SERVER_NAMEzCGI/1.1ZGATEWAY_INTERFACEZ SERVER_PORT� � REMOTE_HOST�CONTENT_LENGTHZ SCRIPT_NAME)� base_environZ server_name�strZ server_port)r �envr r r r 5 s
zWSGIServer.setup_environc C s | j S �N�� applicationr r r r �get_app? � zWSGIServer.get_appc C s
|| _ d S r" r# )r r$ r r r �set_appB s
zWSGIServer.set_app) r r r �__doc__r$ r r r% r' r r r r r * s
r c @ s, e Zd Zde Zdd� Zdd� Zdd� ZdS ) r r
c C sL | j j�� }| j|d< | j|d< | j|d< d| jv r$| j�dd�\}}n| jd}}tj �
|d�|d< ||d < | � � }|| j d
krF||d < | j d
|d < | j
�d
�d u r]| j
�� |d< n| j
d
|d< | j
�d�}|rp||d< | j
�� D ].\}}|�dd��� }|�� }||v r�qud| |v r�|d| d| 7 < qu||d| < qu|S )NZSERVER_PROTOCOLZSERVER_SOFTWAREZREQUEST_METHOD�?r r z
iso-8859-1Z PATH_INFOZ QUERY_STRINGr r Z REMOTE_ADDRz content-typeZ CONTENT_TYPEzcontent-lengthr �-�_ZHTTP_�,)�serverr �copy�request_version�server_version�command�pathr �urllib�parseZunquoteZaddress_stringZclient_addressZheaders�getZget_content_type�items�replace�upper�strip)r r! r2 Zquery�hostZlength�k�vr r r � get_environK s6
z WSGIRequestHandler.get_environc C s t jS r" )�sys�stderrr r r r �
get_stderrp r& z WSGIRequestHandler.get_stderrc C s� | j �d�| _t| j�dkr d| _d| _d| _| �d� dS | �� s$dS t | j | j
| � � | � � dd�}| |_
|�| j�� � dS )z Handle a single HTTP requesti i r i� NF)Z multithread)Zrfile�readlineZraw_requestline�lenZ requestliner/ r1 Z
send_errorZ
parse_requestr
Zwfiler@ r= r �runr- r% )r Zhandlerr r r �handles s
�zWSGIRequestHandler.handleN)r r r � __version__r0 r= r@ rD r r r r r G s
% r c C sr ddl m} |� }td|d� t|d� t| �� �}|D ]\}}t|dt|�|d� q |ddg� |�� �d�gS ) Nr )�StringIOz Hello world!)�file�=z200 OK)z Content-Typeztext/plain; charset=utf-8zutf-8)�iorF �print�sortedr6 �repr�getvalue�encode)�environZstart_responserF �stdout�hr; r< r r r r � s
r c C s || |f|�}|� |� |S )zACreate a new WSGI server listening on `host` and `port` for `app`)r' )r: �portZappZ server_classZ
handler_classr- r r r r � s
r �__main__r i@ zServing HTTP onrR r z...z http://localhost:8000/xyz?abc) r( Z http.serverr r r> Z urllib.parser3 Zwsgiref.handlersr �platformr rE �__all__r0 �versionr � sys_versionr r
r r r r r ZhttpdZsocketZ getsocknameZsarJ Z
webbrowser�openZhandle_requestr r r r �<module> s4 C
�
"�� __init__.py 0000644 00000001113 15154351672 0006662 0 ustar 00 """wsgiref -- a WSGI (PEP 3333) Reference Library
Current Contents:
* util -- Miscellaneous useful functions and wrappers
* headers -- Manage response headers
* handlers -- base classes for server/gateway implementations
* simple_server -- a simple BaseHTTPServer that supports WSGI
* validate -- validation wrapper that sits between an app and a server
to detect errors in either
To-Do:
* cgi_gateway -- Run WSGI apps under CGI (pending a deployment standard)
* cgi_wrapper -- Run CGI apps under WSGI
* router -- a simple middleware component that handles URL traversal
"""
util.py 0000644 00000013333 15154351672 0006107 0 ustar 00 """Miscellaneous WSGI-related Utilities"""
import posixpath
__all__ = [
'FileWrapper', 'guess_scheme', 'application_uri', 'request_uri',
'shift_path_info', 'setup_testing_defaults',
]
class FileWrapper:
"""Wrapper to convert file-like objects to iterables"""
def __init__(self, filelike, blksize=8192):
self.filelike = filelike
self.blksize = blksize
if hasattr(filelike,'close'):
self.close = filelike.close
def __getitem__(self,key):
import warnings
warnings.warn(
"FileWrapper's __getitem__ method ignores 'key' parameter. "
"Use iterator protocol instead.",
DeprecationWarning,
stacklevel=2
)
data = self.filelike.read(self.blksize)
if data:
return data
raise IndexError
def __iter__(self):
return self
def __next__(self):
data = self.filelike.read(self.blksize)
if data:
return data
raise StopIteration
def guess_scheme(environ):
"""Return a guess for whether 'wsgi.url_scheme' should be 'http' or 'https'
"""
if environ.get("HTTPS") in ('yes','on','1'):
return 'https'
else:
return 'http'
def application_uri(environ):
"""Return the application's base URI (no PATH_INFO or QUERY_STRING)"""
url = environ['wsgi.url_scheme']+'://'
from urllib.parse import quote
if environ.get('HTTP_HOST'):
url += environ['HTTP_HOST']
else:
url += environ['SERVER_NAME']
if environ['wsgi.url_scheme'] == 'https':
if environ['SERVER_PORT'] != '443':
url += ':' + environ['SERVER_PORT']
else:
if environ['SERVER_PORT'] != '80':
url += ':' + environ['SERVER_PORT']
url += quote(environ.get('SCRIPT_NAME') or '/', encoding='latin1')
return url
def request_uri(environ, include_query=True):
"""Return the full request URI, optionally including the query string"""
url = application_uri(environ)
from urllib.parse import quote
path_info = quote(environ.get('PATH_INFO',''), safe='/;=,', encoding='latin1')
if not environ.get('SCRIPT_NAME'):
url += path_info[1:]
else:
url += path_info
if include_query and environ.get('QUERY_STRING'):
url += '?' + environ['QUERY_STRING']
return url
def shift_path_info(environ):
"""Shift a name from PATH_INFO to SCRIPT_NAME, returning it
If there are no remaining path segments in PATH_INFO, return None.
Note: 'environ' is modified in-place; use a copy if you need to keep
the original PATH_INFO or SCRIPT_NAME.
Note: when PATH_INFO is just a '/', this returns '' and appends a trailing
'/' to SCRIPT_NAME, even though empty path segments are normally ignored,
and SCRIPT_NAME doesn't normally end in a '/'. This is intentional
behavior, to ensure that an application can tell the difference between
'/x' and '/x/' when traversing to objects.
"""
path_info = environ.get('PATH_INFO','')
if not path_info:
return None
path_parts = path_info.split('/')
path_parts[1:-1] = [p for p in path_parts[1:-1] if p and p != '.']
name = path_parts[1]
del path_parts[1]
script_name = environ.get('SCRIPT_NAME','')
script_name = posixpath.normpath(script_name+'/'+name)
if script_name.endswith('/'):
script_name = script_name[:-1]
if not name and not script_name.endswith('/'):
script_name += '/'
environ['SCRIPT_NAME'] = script_name
environ['PATH_INFO'] = '/'.join(path_parts)
# Special case: '/.' on PATH_INFO doesn't get stripped,
# because we don't strip the last element of PATH_INFO
# if there's only one path part left. Instead of fixing this
# above, we fix it here so that PATH_INFO gets normalized to
# an empty string in the environ.
if name=='.':
name = None
return name
def setup_testing_defaults(environ):
"""Update 'environ' with trivial defaults for testing purposes
This adds various parameters required for WSGI, including HTTP_HOST,
SERVER_NAME, SERVER_PORT, REQUEST_METHOD, SCRIPT_NAME, PATH_INFO,
and all of the wsgi.* variables. It only supplies default values,
and does not replace any existing settings for these variables.
This routine is intended to make it easier for unit tests of WSGI
servers and applications to set up dummy environments. It should *not*
be used by actual WSGI servers or applications, since the data is fake!
"""
environ.setdefault('SERVER_NAME','127.0.0.1')
environ.setdefault('SERVER_PROTOCOL','HTTP/1.0')
environ.setdefault('HTTP_HOST',environ['SERVER_NAME'])
environ.setdefault('REQUEST_METHOD','GET')
if 'SCRIPT_NAME' not in environ and 'PATH_INFO' not in environ:
environ.setdefault('SCRIPT_NAME','')
environ.setdefault('PATH_INFO','/')
environ.setdefault('wsgi.version', (1,0))
environ.setdefault('wsgi.run_once', 0)
environ.setdefault('wsgi.multithread', 0)
environ.setdefault('wsgi.multiprocess', 0)
from io import StringIO, BytesIO
environ.setdefault('wsgi.input', BytesIO())
environ.setdefault('wsgi.errors', StringIO())
environ.setdefault('wsgi.url_scheme',guess_scheme(environ))
if environ['wsgi.url_scheme']=='http':
environ.setdefault('SERVER_PORT', '80')
elif environ['wsgi.url_scheme']=='https':
environ.setdefault('SERVER_PORT', '443')
_hoppish = {
'connection', 'keep-alive', 'proxy-authenticate',
'proxy-authorization', 'te', 'trailers', 'transfer-encoding',
'upgrade'
}.__contains__
def is_hop_by_hop(header_name):
"""Return true if 'header_name' is an HTTP/1.1 "Hop-by-Hop" header"""
return _hoppish(header_name.lower())
headers.py 0000644 00000015156 15154351672 0006552 0 ustar 00 """Manage HTTP Response Headers
Much of this module is red-handedly pilfered from email.message in the stdlib,
so portions are Copyright (C) 2001,2002 Python Software Foundation, and were
written by Barry Warsaw.
"""
# Regular expression that matches `special' characters in parameters, the
# existence of which force quoting of the parameter value.
import re
tspecials = re.compile(r'[ \(\)<>@,;:\\"/\[\]\?=]')
def _formatparam(param, value=None, quote=1):
"""Convenience function to format and return a key=value pair.
This will quote the value if needed or if quote is true.
"""
if value is not None and len(value) > 0:
if quote or tspecials.search(value):
value = value.replace('\\', '\\\\').replace('"', r'\"')
return '%s="%s"' % (param, value)
else:
return '%s=%s' % (param, value)
else:
return param
class Headers:
"""Manage a collection of HTTP response headers"""
def __init__(self, headers=None):
headers = headers if headers is not None else []
if type(headers) is not list:
raise TypeError("Headers must be a list of name/value tuples")
self._headers = headers
if __debug__:
for k, v in headers:
self._convert_string_type(k)
self._convert_string_type(v)
def _convert_string_type(self, value):
"""Convert/check value type."""
if type(value) is str:
return value
raise AssertionError("Header names/values must be"
" of type str (got {0})".format(repr(value)))
def __len__(self):
"""Return the total number of headers, including duplicates."""
return len(self._headers)
def __setitem__(self, name, val):
"""Set the value of a header."""
del self[name]
self._headers.append(
(self._convert_string_type(name), self._convert_string_type(val)))
def __delitem__(self,name):
"""Delete all occurrences of a header, if present.
Does *not* raise an exception if the header is missing.
"""
name = self._convert_string_type(name.lower())
self._headers[:] = [kv for kv in self._headers if kv[0].lower() != name]
def __getitem__(self,name):
"""Get the first header value for 'name'
Return None if the header is missing instead of raising an exception.
Note that if the header appeared multiple times, the first exactly which
occurrence gets returned is undefined. Use getall() to get all
the values matching a header field name.
"""
return self.get(name)
def __contains__(self, name):
"""Return true if the message contains the header."""
return self.get(name) is not None
def get_all(self, name):
"""Return a list of all the values for the named field.
These will be sorted in the order they appeared in the original header
list or were added to this instance, and may contain duplicates. Any
fields deleted and re-inserted are always appended to the header list.
If no fields exist with the given name, returns an empty list.
"""
name = self._convert_string_type(name.lower())
return [kv[1] for kv in self._headers if kv[0].lower()==name]
def get(self,name,default=None):
"""Get the first header value for 'name', or return 'default'"""
name = self._convert_string_type(name.lower())
for k,v in self._headers:
if k.lower()==name:
return v
return default
def keys(self):
"""Return a list of all the header field names.
These will be sorted in the order they appeared in the original header
list, or were added to this instance, and may contain duplicates.
Any fields deleted and re-inserted are always appended to the header
list.
"""
return [k for k, v in self._headers]
def values(self):
"""Return a list of all header values.
These will be sorted in the order they appeared in the original header
list, or were added to this instance, and may contain duplicates.
Any fields deleted and re-inserted are always appended to the header
list.
"""
return [v for k, v in self._headers]
def items(self):
"""Get all the header fields and values.
These will be sorted in the order they were in the original header
list, or were added to this instance, and may contain duplicates.
Any fields deleted and re-inserted are always appended to the header
list.
"""
return self._headers[:]
def __repr__(self):
return "%s(%r)" % (self.__class__.__name__, self._headers)
def __str__(self):
"""str() returns the formatted headers, complete with end line,
suitable for direct HTTP transmission."""
return '\r\n'.join(["%s: %s" % kv for kv in self._headers]+['',''])
def __bytes__(self):
return str(self).encode('iso-8859-1')
def setdefault(self,name,value):
"""Return first matching header value for 'name', or 'value'
If there is no header named 'name', add a new header with name 'name'
and value 'value'."""
result = self.get(name)
if result is None:
self._headers.append((self._convert_string_type(name),
self._convert_string_type(value)))
return value
else:
return result
def add_header(self, _name, _value, **_params):
"""Extended header setting.
_name is the header field to add. keyword arguments can be used to set
additional parameters for the header field, with underscores converted
to dashes. Normally the parameter will be added as key="value" unless
value is None, in which case only the key will be added.
Example:
h.add_header('content-disposition', 'attachment', filename='bud.gif')
Note that unlike the corresponding 'email.message' method, this does
*not* handle '(charset, language, value)' tuples: all values must be
strings or None.
"""
parts = []
if _value is not None:
_value = self._convert_string_type(_value)
parts.append(_value)
for k, v in _params.items():
k = self._convert_string_type(k)
if v is None:
parts.append(k.replace('_', '-'))
else:
v = self._convert_string_type(v)
parts.append(_formatparam(k.replace('_', '-'), v))
self._headers.append((self._convert_string_type(_name), "; ".join(parts)))
validate.py 0000644 00000035371 15154351672 0006731 0 ustar 00 # (c) 2005 Ian Bicking and contributors; written for Paste (http://pythonpaste.org)
# Licensed under the MIT license: https://opensource.org/licenses/mit-license.php
# Also licenced under the Apache License, 2.0: https://opensource.org/licenses/apache2.0.php
# Licensed to PSF under a Contributor Agreement
"""
Middleware to check for obedience to the WSGI specification.
Some of the things this checks:
* Signature of the application and start_response (including that
keyword arguments are not used).
* Environment checks:
- Environment is a dictionary (and not a subclass).
- That all the required keys are in the environment: REQUEST_METHOD,
SERVER_NAME, SERVER_PORT, wsgi.version, wsgi.input, wsgi.errors,
wsgi.multithread, wsgi.multiprocess, wsgi.run_once
- That HTTP_CONTENT_TYPE and HTTP_CONTENT_LENGTH are not in the
environment (these headers should appear as CONTENT_LENGTH and
CONTENT_TYPE).
- Warns if QUERY_STRING is missing, as the cgi module acts
unpredictably in that case.
- That CGI-style variables (that don't contain a .) have
(non-unicode) string values
- That wsgi.version is a tuple
- That wsgi.url_scheme is 'http' or 'https' (@@: is this too
restrictive?)
- Warns if the REQUEST_METHOD is not known (@@: probably too
restrictive).
- That SCRIPT_NAME and PATH_INFO are empty or start with /
- That at least one of SCRIPT_NAME or PATH_INFO are set.
- That CONTENT_LENGTH is a positive integer.
- That SCRIPT_NAME is not '/' (it should be '', and PATH_INFO should
be '/').
- That wsgi.input has the methods read, readline, readlines, and
__iter__
- That wsgi.errors has the methods flush, write, writelines
* The status is a string, contains a space, starts with an integer,
and that integer is in range (> 100).
* That the headers is a list (not a subclass, not another kind of
sequence).
* That the items of the headers are tuples of strings.
* That there is no 'status' header (that is used in CGI, but not in
WSGI).
* That the headers don't contain newlines or colons, end in _ or -, or
contain characters codes below 037.
* That Content-Type is given if there is content (CGI often has a
default content type, but WSGI does not).
* That no Content-Type is given when there is no content (@@: is this
too restrictive?)
* That the exc_info argument to start_response is a tuple or None.
* That all calls to the writer are with strings, and no other methods
on the writer are accessed.
* That wsgi.input is used properly:
- .read() is called with exactly one argument
- That it returns a string
- That readline, readlines, and __iter__ return strings
- That .close() is not called
- No other methods are provided
* That wsgi.errors is used properly:
- .write() and .writelines() is called with a string
- That .close() is not called, and no other methods are provided.
* The response iterator:
- That it is not a string (it should be a list of a single string; a
string will work, but perform horribly).
- That .__next__() returns a string
- That the iterator is not iterated over until start_response has
been called (that can signal either a server or application
error).
- That .close() is called (doesn't raise exception, only prints to
sys.stderr, because we only know it isn't called when the object
is garbage collected).
"""
__all__ = ['validator']
import re
import sys
import warnings
header_re = re.compile(r'^[a-zA-Z][a-zA-Z0-9\-_]*$')
bad_header_value_re = re.compile(r'[\000-\037]')
class WSGIWarning(Warning):
"""
Raised in response to WSGI-spec-related warnings
"""
def assert_(cond, *args):
if not cond:
raise AssertionError(*args)
def check_string_type(value, title):
if type (value) is str:
return value
raise AssertionError(
"{0} must be of type str (got {1})".format(title, repr(value)))
def validator(application):
"""
When applied between a WSGI server and a WSGI application, this
middleware will check for WSGI compliance on a number of levels.
This middleware does not modify the request or response in any
way, but will raise an AssertionError if anything seems off
(except for a failure to close the application iterator, which
will be printed to stderr -- there's no way to raise an exception
at that point).
"""
def lint_app(*args, **kw):
assert_(len(args) == 2, "Two arguments required")
assert_(not kw, "No keyword arguments allowed")
environ, start_response = args
check_environ(environ)
# We use this to check if the application returns without
# calling start_response:
start_response_started = []
def start_response_wrapper(*args, **kw):
assert_(len(args) == 2 or len(args) == 3, (
"Invalid number of arguments: %s" % (args,)))
assert_(not kw, "No keyword arguments allowed")
status = args[0]
headers = args[1]
if len(args) == 3:
exc_info = args[2]
else:
exc_info = None
check_status(status)
check_headers(headers)
check_content_type(status, headers)
check_exc_info(exc_info)
start_response_started.append(None)
return WriteWrapper(start_response(*args))
environ['wsgi.input'] = InputWrapper(environ['wsgi.input'])
environ['wsgi.errors'] = ErrorWrapper(environ['wsgi.errors'])
iterator = application(environ, start_response_wrapper)
assert_(iterator is not None and iterator != False,
"The application must return an iterator, if only an empty list")
check_iterator(iterator)
return IteratorWrapper(iterator, start_response_started)
return lint_app
class InputWrapper:
def __init__(self, wsgi_input):
self.input = wsgi_input
def read(self, *args):
assert_(len(args) == 1)
v = self.input.read(*args)
assert_(type(v) is bytes)
return v
def readline(self, *args):
assert_(len(args) <= 1)
v = self.input.readline(*args)
assert_(type(v) is bytes)
return v
def readlines(self, *args):
assert_(len(args) <= 1)
lines = self.input.readlines(*args)
assert_(type(lines) is list)
for line in lines:
assert_(type(line) is bytes)
return lines
def __iter__(self):
while 1:
line = self.readline()
if not line:
return
yield line
def close(self):
assert_(0, "input.close() must not be called")
class ErrorWrapper:
def __init__(self, wsgi_errors):
self.errors = wsgi_errors
def write(self, s):
assert_(type(s) is str)
self.errors.write(s)
def flush(self):
self.errors.flush()
def writelines(self, seq):
for line in seq:
self.write(line)
def close(self):
assert_(0, "errors.close() must not be called")
class WriteWrapper:
def __init__(self, wsgi_writer):
self.writer = wsgi_writer
def __call__(self, s):
assert_(type(s) is bytes)
self.writer(s)
class PartialIteratorWrapper:
def __init__(self, wsgi_iterator):
self.iterator = wsgi_iterator
def __iter__(self):
# We want to make sure __iter__ is called
return IteratorWrapper(self.iterator, None)
class IteratorWrapper:
def __init__(self, wsgi_iterator, check_start_response):
self.original_iterator = wsgi_iterator
self.iterator = iter(wsgi_iterator)
self.closed = False
self.check_start_response = check_start_response
def __iter__(self):
return self
def __next__(self):
assert_(not self.closed,
"Iterator read after closed")
v = next(self.iterator)
if type(v) is not bytes:
assert_(False, "Iterator yielded non-bytestring (%r)" % (v,))
if self.check_start_response is not None:
assert_(self.check_start_response,
"The application returns and we started iterating over its body, but start_response has not yet been called")
self.check_start_response = None
return v
def close(self):
self.closed = True
if hasattr(self.original_iterator, 'close'):
self.original_iterator.close()
def __del__(self):
if not self.closed:
sys.stderr.write(
"Iterator garbage collected without being closed")
assert_(self.closed,
"Iterator garbage collected without being closed")
def check_environ(environ):
assert_(type(environ) is dict,
"Environment is not of the right type: %r (environment: %r)"
% (type(environ), environ))
for key in ['REQUEST_METHOD', 'SERVER_NAME', 'SERVER_PORT',
'wsgi.version', 'wsgi.input', 'wsgi.errors',
'wsgi.multithread', 'wsgi.multiprocess',
'wsgi.run_once']:
assert_(key in environ,
"Environment missing required key: %r" % (key,))
for key in ['HTTP_CONTENT_TYPE', 'HTTP_CONTENT_LENGTH']:
assert_(key not in environ,
"Environment should not have the key: %s "
"(use %s instead)" % (key, key[5:]))
if 'QUERY_STRING' not in environ:
warnings.warn(
'QUERY_STRING is not in the WSGI environment; the cgi '
'module will use sys.argv when this variable is missing, '
'so application errors are more likely',
WSGIWarning)
for key in environ.keys():
if '.' in key:
# Extension, we don't care about its type
continue
assert_(type(environ[key]) is str,
"Environmental variable %s is not a string: %r (value: %r)"
% (key, type(environ[key]), environ[key]))
assert_(type(environ['wsgi.version']) is tuple,
"wsgi.version should be a tuple (%r)" % (environ['wsgi.version'],))
assert_(environ['wsgi.url_scheme'] in ('http', 'https'),
"wsgi.url_scheme unknown: %r" % environ['wsgi.url_scheme'])
check_input(environ['wsgi.input'])
check_errors(environ['wsgi.errors'])
# @@: these need filling out:
if environ['REQUEST_METHOD'] not in (
'GET', 'HEAD', 'POST', 'OPTIONS', 'PATCH', 'PUT', 'DELETE', 'TRACE'):
warnings.warn(
"Unknown REQUEST_METHOD: %r" % environ['REQUEST_METHOD'],
WSGIWarning)
assert_(not environ.get('SCRIPT_NAME')
or environ['SCRIPT_NAME'].startswith('/'),
"SCRIPT_NAME doesn't start with /: %r" % environ['SCRIPT_NAME'])
assert_(not environ.get('PATH_INFO')
or environ['PATH_INFO'].startswith('/'),
"PATH_INFO doesn't start with /: %r" % environ['PATH_INFO'])
if environ.get('CONTENT_LENGTH'):
assert_(int(environ['CONTENT_LENGTH']) >= 0,
"Invalid CONTENT_LENGTH: %r" % environ['CONTENT_LENGTH'])
if not environ.get('SCRIPT_NAME'):
assert_('PATH_INFO' in environ,
"One of SCRIPT_NAME or PATH_INFO are required (PATH_INFO "
"should at least be '/' if SCRIPT_NAME is empty)")
assert_(environ.get('SCRIPT_NAME') != '/',
"SCRIPT_NAME cannot be '/'; it should instead be '', and "
"PATH_INFO should be '/'")
def check_input(wsgi_input):
for attr in ['read', 'readline', 'readlines', '__iter__']:
assert_(hasattr(wsgi_input, attr),
"wsgi.input (%r) doesn't have the attribute %s"
% (wsgi_input, attr))
def check_errors(wsgi_errors):
for attr in ['flush', 'write', 'writelines']:
assert_(hasattr(wsgi_errors, attr),
"wsgi.errors (%r) doesn't have the attribute %s"
% (wsgi_errors, attr))
def check_status(status):
status = check_string_type(status, "Status")
# Implicitly check that we can turn it into an integer:
status_code = status.split(None, 1)[0]
assert_(len(status_code) == 3,
"Status codes must be three characters: %r" % status_code)
status_int = int(status_code)
assert_(status_int >= 100, "Status code is invalid: %r" % status_int)
if len(status) < 4 or status[3] != ' ':
warnings.warn(
"The status string (%r) should be a three-digit integer "
"followed by a single space and a status explanation"
% status, WSGIWarning)
def check_headers(headers):
assert_(type(headers) is list,
"Headers (%r) must be of type list: %r"
% (headers, type(headers)))
for item in headers:
assert_(type(item) is tuple,
"Individual headers (%r) must be of type tuple: %r"
% (item, type(item)))
assert_(len(item) == 2)
name, value = item
name = check_string_type(name, "Header name")
value = check_string_type(value, "Header value")
assert_(name.lower() != 'status',
"The Status header cannot be used; it conflicts with CGI "
"script, and HTTP status is not given through headers "
"(value: %r)." % value)
assert_('\n' not in name and ':' not in name,
"Header names may not contain ':' or '\\n': %r" % name)
assert_(header_re.search(name), "Bad header name: %r" % name)
assert_(not name.endswith('-') and not name.endswith('_'),
"Names may not end in '-' or '_': %r" % name)
if bad_header_value_re.search(value):
assert_(0, "Bad header value: %r (bad char: %r)"
% (value, bad_header_value_re.search(value).group(0)))
def check_content_type(status, headers):
status = check_string_type(status, "Status")
code = int(status.split(None, 1)[0])
# @@: need one more person to verify this interpretation of RFC 2616
# http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html
NO_MESSAGE_BODY = (204, 304)
for name, value in headers:
name = check_string_type(name, "Header name")
if name.lower() == 'content-type':
if code not in NO_MESSAGE_BODY:
return
assert_(0, ("Content-Type header found in a %s response, "
"which must not return content.") % code)
if code not in NO_MESSAGE_BODY:
assert_(0, "No Content-Type header found in headers (%s)" % headers)
def check_exc_info(exc_info):
assert_(exc_info is None or type(exc_info) is tuple,
"exc_info (%r) is not a tuple: %r" % (exc_info, type(exc_info)))
# More exc_info checks?
def check_iterator(iterator):
# Technically a bytestring is legal, which is why it's a really bad
# idea, because it may cause the response to be returned
# character-by-character
assert_(not isinstance(iterator, (str, bytes)),
"You should not return a string as your application iterator, "
"instead return a single-item list containing a bytestring.")
