Python Tenth Step: Web 客户端和服务器

values = urlparse("http://so.csdn.net/so/search/s.do?q=AAA啊哈&t=blog")
print(values)   # ParseResult(scheme='http', netloc='so.csdn.net', path='/so/search/s.do', params='', query='q=AAA啊哈&t=blog', fragment='')
print(urlunparse(values))   # http://so.csdn.net/so/search/s.do?q=AAA啊哈&t=blog

print(urljoin('https://docs.python.org/3/faq/index.html', 'general.html#what-is-python'))
# https://docs.python.org/3/faq/general.html#what-is-python

quote('abc def')    # 'abc%20def'

quote_plus('abc def')   # 'abc+def'

import urllib.request, urllib.error, urllib.parse

LOGIN = 'wesley'
PASSWD = "you'llNeverGuess"
URL = 'http://localhost'
REALM = 'Secure Archive'


def handler_version(url):
    hdlr = urllib.request.HTTPBasicAuthHandler()
    hdlr.add_password(REALM, urllib.parse.urlparse(url)[1], LOGIN, PASSWD)
    opener = urllib.request.build_opener(hdlr)
    urllib.request.install_opener(opener)
    return url


def request_version(url):
    from base64 import encodestring
    req = urllib.request.Request(url)   # 创建一个 request 对象
    b64str = encodestring(bytes('%s:%s' % (LOGIN, PASSWD), 'utf-8'))[:-1]   # 验证头信息
    req.add_header("Authorization", "Basic %s" % b64str)
    return req


for funcType in ('handler', 'request'):
    print('*** Using %s:' % funcType.upper())
    url = eval('%s_version' % funcType)(URL)
    f = urllib.request.urlopen(url)
    print(str(f.readline(), 'utf-8'))
    f.close()

import requests
from bs4 import BeautifulSoup

server = 'http://www.biqukan.com'
target = 'http://www.biqukan.com/1_1496/'


def req_get_bf(url):
    return BeautifulSoup(requests.get(url).text, 'html.parser')


def get_content(content_url):
    bf = req_get_bf(content_url)
    texts = bf.find_all('div', 'showtxt')
    return texts[0].text.replace('\xa0' * 8, '\n\n')


def get_target_url(main_url, name_list, url_list):
    div_bf = req_get_bf(main_url)
    div = div_bf.find_all('div', 'listmain')
    a_div_bf = BeautifulSoup(str(div[0]), 'html.parser')
    a = a_div_bf.find_all('a')[12:]
    for item in a:
        url_list.append(server + item.get('href'))
        name_list.append(item.string)

    return len(a)


def write_to_file(name, path, text):
    with open(path, 'a', encoding='utf-8') as f:
        f.write(name + '\n')
        f.writelines(text)
        f.write('\n\n')


if __name__ == '__main__':
    names = []  # 存放章节名
    urls = []  # 存放章节链接
    nums = get_target_url(target, names, urls)
    for i in range(nums):
        print('正在下载', names[i])
        write_to_file(names[i], '龙王传说.txt', get_content(urls[i]))

from http.server import BaseHTTPRequestHandler, HTTPServer


class MyHandler(BaseHTTPRequestHandler):
    def do_get(self):
        try:
            f = open(self.path[1:], 'r')
            self.send_response(200)
            self.send_header('Content-type', 'text/html')
            self.end_headers()
            self.wfile.write(f.read())
            f.close()
        except IOError:
            self.send_error(404, 'File Not Found: %s' % self.path)


def main():
    server = HTTPServer(('', 8080), MyHandler)
    try:
        print('Welcome to the machine...')
        print('Press ^C once or twice to quit')
        server.serve_forever()
    except KeyboardInterrupt:
        print('^C received, shutting down server')
    finally:
        if server:
            server.socket.close()


if __name__ == '__main__':
    main()

from http.server import CGIHTTPRequestHandler, test


test(CGIHTTPRequestHandler)     # test 默认 port 为 8000

http://localhost:8000/hello.htm
http://localhost:8080/cgi-bin/helloA.py

form = cgi.FieldStorage()   # 获取 表单
    if 'person' in form:
        who = form['person'].value  # 获取表单中 key person 的值
    else:
        who = 'NEW USER'

print(who)  # 通过 print 返回数据

print('''Content-Type: text/html; charset=UTF-8

真实数据
'''.replace('\n', '\r\n'))

from os import environ


if 'HTTP_COOKIE' in environ:    # 获取 cookie
    cookies = [x.strip() for x in environ['HTTP_COOKIE'].split(';')]

print('Set-Cookie: cookie_key=cookie_value; path=/') 

def simple_wsgi_app(environ, start_response): 
    status = '200 OK' 
    headers = [('Content-type', 'text/plain')] 
    start_response(status, headers) 
    return ['Hello world!']

"""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()
        )
        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