pychrome安装和入门

def __getattr__(self, item):
    attr = GenericAttr(item, self)
    setattr(self, item, attr)
    return attr

import pychrome

browser = pychrome.Browser(url="http://127.0.0.1:9222")
tab = browser.new_tab()

def request_will_be_sent(**kwargs):
    print("loading: %s" % kwargs.get('request').get('url'))


tab.set_listener("Network.requestWillBeSent", request_will_be_sent)

tab.start()
tab.call_method("Network.enable")
tab.call_method("Page.navigate", url="https://github.com/fate0/pychrome", _timeout=5)

tab.wait(5)
tab.stop()

browser.close_tab(tab)

import time
import pychrome


class EventHandler(object):
    def __init__(self, browser, tab):
        self.browser = browser
        self.tab = tab
        self.start_frame = None
        self.is_first_request = True
        self.html_content = None

    def frame_started_loading(self, frameId):
        if not self.start_frame:
            self.start_frame = frameId

    def request_intercepted(self, interceptionId, request, **kwargs):
        if self.is_first_request:
            self.is_first_request = False
            headers = request.get('headers', {})
            headers['Test-key'] = 'test-value'
            self.tab.Network.continueInterceptedRequest(
                interceptionId=interceptionId,
                headers=headers,
                method='POST',
                postData="hello post data: %s" % time.time()
            )
        else:
            self.tab.Network.continueInterceptedRequest(
                interceptionId=interceptionId
            )

    def frame_stopped_loading(self, frameId):
        if self.start_frame == frameId:
            self.tab.Page.stopLoading()
            result = self.tab.Runtime.evaluate(expression="document.documentElement.outerHTML")
            self.html_content = result.get('result', {}).get('value', "")
            print(self.html_content)
            self.tab.stop()


def close_all_tabs(browser):
    if len(browser.list_tab()) == 0:
        return

    for tab in browser.list_tab():
        try:
            tab.stop()
        except pychrome.RuntimeException:
            pass

        browser.close_tab(tab)

    time.sleep(1)
    assert len(browser.list_tab()) == 0


def main():
    browser = pychrome.Browser()

    close_all_tabs(browser)

    tabs = []
    for i in range(4):
        tabs.append(browser.new_tab())

    for i, tab in enumerate(tabs):
        eh = EventHandler(browser, tab)
        tab.Network.requestIntercepted = eh.request_intercepted
        tab.Page.frameStartedLoading = eh.frame_started_loading
        tab.Page.frameStoppedLoading = eh.frame_stopped_loading

        tab.start()
        tab.Page.stopLoading()
        tab.Page.enable()
        tab.Network.setRequestInterceptionEnabled(enabled=True)
        tab.Page.navigate(url="http://httpbin.org/post")

    for tab in tabs:
        tab.wait(60)
        tab.stop()
        browser.close_tab(tab)

    print('Done')


if __name__ == '__main__':
    main()

import pychrome
import time
import urllib



class ChromiumClient(object):
    """ Client to interact with Chromium """

    def __init__(self):
        self.browser = pychrome.Browser(url="http://127.0.0.1:9222")

    def do_post(self):
        self.tab = self.browser.new_tab()

        event_handler = EventHandler()

        event_handler.set_token('asdkflj497564dsklf')
        event_handler.set_post_data({
            'param1': 'value1',
            'param2': 'value2'
        })

        url_pattern_object = {'urlPattern': '*fate0*'}
        self.tab.Network.setRequestInterception(patterns=[url_pattern_object])

        self.tab.Network.requestIntercepted = event_handler.on_request_intercepted

        self.tab.start()

        self.tab.Network.enable()
        self.tab.Page.enable()

        self.tab.Page.navigate(url='https://github.com/fate0/pychrome')

        self.tab.wait(5)
        self.tab.stop()

        self.browser.close_tab(self.tab.id)


class EventHandler(object):
    def __init__(self):
        self.tab = None
        self.token = None
        self.is_first_request = False
        self.post_data = {}

    def set_tab(self, t):
        self.tab = t

    def set_token(self, t):
        self.token = t

    def set_post_data(self, pd):
        self.post_data = pd

    def on_request_intercepted(self, **kwargs):
        new_args = {'interceptionId': kwargs['interceptionId']}

        if self.is_first_request:
            # Modify first request only, following are media/static
            # requests...
            self.is_first_request = False

            extra_headers = {
                'Requested-by': 'Chromium',
                'Authorization': 'Token ' + self.token
            }

            request = kwargs.get('request')
            request['headers'].update(extra_headers)

            new_args.update({
                'url': request['url'],
                'method': 'POST',
                'headers': request['headers'],
                'postData': urllib.urlencode(self.post_data)
            })

        self.tab.Network.continueInterceptedRequest(**new_args)


if __name__ == '__main__':
    client = ChromiumClient()

    client.do_post()