Esempio n. 1
0
def http_request(url, post=None, headers=None):
    """Perform an HTTP request."""
    if headers is None:
        headers = {}
    request = Request(url)
    request.add_header(
        'User-Agent',
        'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/1337 Safari/537.36'
    )

    for key in headers:
        request.add_header(key, headers[key])

    if post:
        post = urlencode(post).encode("utf-8")

    opener = build_opener(HTTPCookieProcessor(cookie_jar))
    response = opener.open(request, data=post)

    response_code = response.getcode()
    if response_code not in [200, 204]:
        raise Exception('Bad return code (' + str(response_code) + ') for: ' +
                        url)

    return response.read(), response_code
Esempio n. 2
0
def cookie_login(loginurl, values):
    """ Open a session

    login_url : the login url
    values : dictionary containing login form field
    """
    global urlOpener
    # Enable cookie support for urllib2
    mcookiejar = cookiejar.CookieJar()
    urlOpener = build_opener(HTTPCookieProcessor(mcookiejar),
                             MultipartPostHandler)

    data = urlencode(values)
    request = Request(loginurl, data)
    url = urlOpener.open(
        request)  # Our mcookiejar automatically receives the cookies
    urllib.request.install_opener(urlOpener)

    # Make sure we are logged in by checking the presence of the cookie "session_ser".
    # (which is the cookie containing the session identifier.)
    if not 'session_ser' in [cookie.name for cookie in mcookiejar]:
        print("Login failed !")
        return False
    else:
        print("We are logged in !")
        return True
Esempio n. 3
0
def get_cookies(proxy, url, useragent, timeout=.500):
    proxy_support = ProxyHandler({'https': proxy})
    cj = CookieJar()
    opener = build_opener(proxy_support, HTTPCookieProcessor(cj))
    install_opener(opener)

    headers = {
        'accept':
        'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9',
        'accept-language': 'en-US,en;q=0.9,fr-FR;q=0.8,fr;q=0.7',
        'cache-control': 'no-cache',
        'dnt': '1',
        'pragma': 'no-cache',
        'referer': 'https://www.google.com',
        'sec-fetch-mode': 'navigate',
        'sec-fetch-site': 'same-origin',
        'sec-fetch-user': '******',
        'upgrade-insecure-requests': '1',
        'user-agent': useragent,
    }

    req = Request(url, data=None, headers=headers, method='GET')
    try:
        urlopen(req, timeout=timeout)
        return dict_from_cookiejar(cj)

    except URLError as e:
        print(bcolors.FAIL + str(e) + bcolors.ENDC)
    except HTTPError as e:
        print(bcolors.FAIL + str(e) + bcolors.ENDC)
    except Exception as e:
        print(bcolors.FAIL + str(e) + bcolors.ENDC)
Esempio n. 4
0
    def _get_new_user_xvrttoken(self):
        """Get new 'user' X-VRT-Token from VRT NU website"""
        # Get login json
        login_json = self._get_login_json()

        if login_json.get('errorCode') != 0:
            return None

        payload = dict(
            UID=login_json.get('UID'),
            UIDSignature=login_json.get('UIDSignature'),
            signatureTimestamp=login_json.get('signatureTimestamp'),
            client_id='vrtnu-site',
            submit='submit',
        )
        data = urlencode(payload).encode()
        cookiejar = cookielib.CookieJar()
        opener = build_opener(HTTPCookieProcessor(cookiejar), ProxyHandler(self._proxies))
        log(2, 'URL get: {url}', url=unquote(self._USER_TOKEN_GATEWAY_URL))
        opener.open(self._USER_TOKEN_GATEWAY_URL)
        log(2, 'URL post: {url}', url=unquote(self._VRT_LOGIN_URL))
        opener.open(self._VRT_LOGIN_URL, data=data)
        xvrttoken = TokenResolver._create_token_dictionary(cookiejar)
        refreshtoken = TokenResolver._create_token_dictionary(cookiejar, cookie_name='vrtlogin-rt')
        if xvrttoken is None:
            return None

        self._set_cached_token(xvrttoken, token_variant='user')
        if refreshtoken is not None:
            self._set_cached_token(refreshtoken)
        return xvrttoken.get('X-VRT-Token')
Esempio n. 5
0
    def login(self, loc=None):
        if loc is None:
            loc = self.get_setting('BASE_LOCATION')
        login_url = self.get_setting('BASE_URL') + \
                self.get_setting('LOGIN_LOCATION')
        cookies = HTTPCookieProcessor()
        opener = build_opener(cookies)
        opener.open(login_url)

        try:
            token = [
                x.value for x in cookies.cookiejar if x.name == 'csrftoken'
            ][0]
        except IndexError:
            raise IOError("No csrf cookie found")

        params = dict(username=self.get_setting('LOGIN_USERNAME'),
                      password=self.get_setting('LOGIN_PASSWORD'),
                      next=loc,
                      csrfmiddlewaretoken=token)
        encoded_params = urlparse.urlencode(params).encode('utf-8')

        req = Request(login_url, encoded_params)
        req.add_header('Referer', login_url)
        response = opener.open(req)
        if response.geturl() == login_url:
            raise IOError("Authentication refused")
        return opener, response
Esempio n. 6
0
    def connect(self):
        """
        authを行う
        :return:
        """

        # cookie付きのオープンハンドラ
        self.opener = build_opener(HTTPCookieProcessor(CookieJar()))
        o = {}
        o["username"] = self.eve_user
        o["password"] = self.eve_pass
        o["html5"] = "-1"
        stJson = json.dumps(o).encode("utf-8")
        headers = {}
        headers["Content-Type"] = "application/json"

        # ログインの試行
        u = "http://{0}/api/auth/login".format((self.host))
        res = self.opener.open(u, stJson)

        # 現在開いているlabの取得
        u = "http://{0}/api/auth".format((self.host))
        res = self.opener.open(u)
        response_body = res.read().decode("utf-8")
        d = json.loads(response_body)
        data = d.get("data", {})
        self.lab = data.get("lab", "")
Esempio n. 7
0
    def __init__(self):
        # error message
        self.error = None

        # establish connection
        self.session = build_opener()

        # add proxy handler if needed
        if config['proxy']:
            if any(config['proxies'].values()):
                self.session.add_handler(ProxyHandler(config['proxies']))
                logger.debug("Proxy is set!")
            else:
                self.error = "Proxy enabled, but not set!"

        # change user-agent
        self.session.addheaders = [('User-Agent', config['ua'])]

        # load local cookies
        mcj = MozillaCookieJar()
        try:
            mcj.load(FILE_C, ignore_discard=True)
            if 'uid' in [cookie.name for cookie in mcj]:
                # if cookie.expires < int(time.time())
                logger.info("Local cookies is loaded")
                self.session.add_handler(HTTPCookieProcessor(mcj))
            else:
                logger.info("Local cookies expired or bad")
                logger.debug(f"That we have: {[cookie for cookie in mcj]}")
                mcj.clear()
                self.login(mcj)
        except FileNotFoundError:
            self.login(mcj)
Esempio n. 8
0
def start(args):
    """Login and session handler
    """
    # create cookiejar
    args._cj = LWPCookieJar()

    # lets urllib handle cookies
    opener = build_opener(HTTPCookieProcessor(args._cj))
    opener.addheaders = [(
        "User-Agent",
        "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/67.0.3396.62 Safari/537.36"
    ), ("Accept-Encoding", "identity"), ("Accept-Charset", "utf-8"),
                         ("DNT", "1")]
    install_opener(opener)

    # load cookies
    try:
        args._cj.load(getCookiePath(args), ignore_discard=True)
    except IOError:
        # cookie file does not exist
        pass

    args._cj.set_cookie(
        Cookie(0, "timezoneoffset", str(timezone // 60), None, False,
               "www.wakanim.tv", False, False, "/", True, False, None, False,
               None, None, {"HttpOnly": None}, False))
Esempio n. 9
0
    def check_initial_sell_trade(self):
        opener = build_opener(HTTPCookieProcessor(CookieJar()))

        urlencoded_login_data = urlencode(self.login_post_data).encode('utf-8')
        try:
            res = opener.open(self.login_url, urlencoded_login_data)
        except:
            logging.warning("failed to login")
            exit("Failed to login.")

        urlencoded_get_stock_holdings_data = urlencode(
            self.get_stock_holdings_post_data).encode('utf-8')
        try:
            res = opener.open(self.get_stock_holdings_url,
                              urlencoded_get_stock_holdings_data)
            html = res.read()
            shift = html.decode('Shift_JIS')
            stock_holdings_num = re.findall(
                "(?<=<br>){}(?=&nbsp;)".format(self.stock_id), shift)
            if not len(stock_holdings_num):
                self.successed_initial_sell_trade = True
                logging.info("Successed initial sell trade of stock {}".format(
                    self.stock_id))
            else:
                self.successed_initial_sell_trade = False
                logging.info(
                    "have not yet done initial sell trade of stock {}".format(
                        self.stock_id))
        except:
            logging.warning(
                "failed to get stock holdings for check initital sell trade")
            self.successed_initail_sell_trade = False

        return
Esempio n. 10
0
def look_up_ele():
    BASE_URL = 'http://m.myhome.tsinghua.edu.cn/'
    LOGIN_URL = BASE_URL + 'Loginwindow.aspx'
    LOOKUP_URL = BASE_URL + 'weixin/weixin_student_electricity_search.aspx'

    data = {
        '__VIEWSTATE':
        '/wEPDwUJMzUxODM3OTcwZGSzjX6gFtY6tdAxR1DJThQLsW0mqCd9bss+APDYXmKA8g==',
        '__VIEWSTATEGENERATOR': '4B45C1AF',
        'LoginCtrl1$txtUserName': settings.username,
        'LoginCtrl1$txtPassword': settings.password,
        'LoginCtrl1$btnLogin': '******'
    }
    cookie = CookieJar()
    handler = HTTPCookieProcessor(cookie)
    opener = build_opener(handler)
    data = urlencode(data).encode('GBK')
    res = opener.open(Request(LOGIN_URL, data)).read().decode('GBK')

    res = opener.open(Request(LOOKUP_URL, data)).read().decode('GBK')
    # with open('res.html', 'w') as f:
    #     f.write(res)

    ele = -1
    for line in res.split('\n'):
        if 'lblele' in line:
            line = line.strip()
            get_ele = re.compile(r'>(\d+)')
            ele = int(get_ele.findall(line)[0])

    return ele
Esempio n. 11
0
def initialReq():
    cookiejar = CookieJar()
    if ('ssl_validation'):
        opener = build_opener(HTTPCookieProcessor(cookiejar), HTTPHandler())
    else:
        opener = build_opener(HTTPCookieProcessor(cookiejar), HTTPHandler(),
                              HTTPSHandler(context=sslvalidation()))

    headers = {
        "Host": "www.linkedin.com",
        "Agent": user_agent,
    }

    req = Request("https://www.linkedin.com")
    f = opener.open(req, timeout=timeout)
    return cookiejar
Esempio n. 12
0
    def __init__(self,
                 mobile,
                 password=None,
                 status='0',
                 cachefile='Fetion.cache',
                 cookiesfile=''):
        '''登录状态:
        在线:400 隐身:0 忙碌:600 离开:100
        '''
        if cachefile:
            self.cache = Cache(cachefile)

        if not cookiesfile:
            cookiesfile = '%s.cookies' % mobile

        cookiejar = MozillaCookieJar(filename=cookiesfile)
        if not os.path.isfile(cookiesfile):
            open(cookiesfile, 'w').write(MozillaCookieJar.header)

        cookiejar.load(filename=cookiesfile)

        cookie_processor = HTTPCookieProcessor(cookiejar)

        self.opener = build_opener(cookie_processor, HTTPHandler)
        self.mobile, self.password = mobile, password
        if not self.alive():
            self._login()
            cookiejar.save()

        self.changestatus(status)
    def login(self, mcj):
        if self.error:
            return
        self.session.add_handler(HTTPCookieProcessor(mcj))

        form_data = {
            "username": config['username'],
            "password": config['password']
        }
        logger.debug(f"Login. Data before: {form_data}")
        # so we first encode vals to cp1251 then do default decode whole string
        data_encoded = urlencode(
            {k: v.encode('cp1251')
             for k, v in form_data.items()}).encode()
        logger.debug(f"Login. Data after: {data_encoded}")

        self._catch_error_request(self.url + 'takelogin.php', data_encoded)
        if self.error:
            return
        logger.debug(f"That we have: {[cookie for cookie in mcj]}")
        if 'uid' in [cookie.name for cookie in mcj]:
            mcj.save(FILE_C, ignore_discard=True, ignore_expires=True)
            logger.info('We successfully authorized')
        else:
            self.error = "We not authorized, please check your credentials!"
            logger.warning(self.error)
Esempio n. 14
0
    def __init__(self):
        #build the opener
        cookie_jar = CookieJar()
        self._url_opener = build_opener(HTTPCookieProcessor(cookie_jar))
        self._url_opener.addheaders =[
                ('Host', 'finance.yahoo.com'),
                ('User-Agent', 'Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:64.0) Gecko/20100101 Firefox/64.0'),
                ('Accept', '*/*'),
                ('Accept-Language', 'en-US,en;q=0.5'),
                ('Accept-Encoding', 'gzip, deflate, br'),
                ('Referer', 'https://finance.yahoo.com/'),
                ('X-Requested-With', 'XMLHttpRequest'),
                ('Connection', 'keep-alive'),
                ('TE', 'Trailers'),
                ('Pragma', 'no-cache'),
                ('Cache-Control', 'no-cache')
                ]

        #First Request to create cookies and access the CrumbStore
        uri='https://finance.yahoo.com/quote/ALUA.BA/history?p=ALUA.BA'

        with self._url_opener.open(Request(uri)) as response:
            with gzip.GzipFile(fileobj=response) as deflated:
                html=deflated.read().decode('utf-8')
                self._crumb = json.loads(re.search('"CrumbStore":({"[^}]*})',html).group(1))["crumb"]
def get_credentials(url):
    """Get user credentials from .netrc or prompt for input."""
    credentials = None
    errprefix = ''
    try:
        info = netrc.netrc()
        username, account, password = info.authenticators(urlparse(URS_URL).hostname)
        errprefix = 'netrc error: '
    except Exception as e:
        if (not ('No such file' in str(e))):
            print('netrc error: {0}'.format(str(e)))
        username = None
        password = None

    while not credentials:
        if not username:
            username = get_username()
            password = get_password()
        credentials = '{0}:{1}'.format(username, password)
        credentials = base64.b64encode(credentials.encode('ascii')).decode('ascii')

        if url:
            try:
                req = Request(url)
                req.add_header('Authorization', 'Basic {0}'.format(credentials))
                opener = build_opener(HTTPCookieProcessor())
                opener.open(req)
            except HTTPError:
                print(errprefix + 'Incorrect username or password')
                errprefix = ''
                credentials = None
                username = None
                password = None

    return credentials
Esempio n. 16
0
def unravel_message(url, cache):
    """Follows the riddle until the end — as in mission 04 — but this time
    looking at the first cookie. Then returns the message decompressed."""
    curr = 12345
    cookie_jar = CookieJar()
    url_opener = build_opener(HTTPCookieProcessor(cookie_jar))
    msg = cache.get("msg", "")
    if not msg:
        while True:
            try:
                resp = url_opener.open(url.format(curr), timeout=3)
                riddle = resp.read().decode()
                cookie = list(cookie_jar)[0]
                msg += cookie.value
            except KeyboardInterrupt:
                sys.exit(0)
            except Exception as e:
                print(f"\nBang! {e} ({curr})")
                sys.exit(1)
            try:
                next_ = int(riddle.split(" ")[-1])
            except ValueError:
                break
            curr = next_
        cache["msg"] = msg
    return bz2.decompress(unquote_to_bytes(msg.replace("+", " "))).decode()
Esempio n. 17
0
    def login(self, mcj):
        if self.error:
            return
        # if we wanna use https we mast add ssl=enable_ssl to cookie
        mcj.set_cookie(Cookie(0, 'ssl', "enable_ssl", None, False,
                              '.rutracker.org', True, False, '/', True,
                              False, None, 'ParserCookie', None, None, None))
        self.session.add_handler(HTTPCookieProcessor(mcj))

        form_data = {"login_username": config['username'],
                     "login_password": config['password'],
                     "login": "******"}
        logger.debug(f"Login. Data before: {form_data}")
        # so we first encode vals to cp1251 then do default decode whole string
        data_encoded = urlencode(
            {k: v.encode('cp1251') for k, v in form_data.items()}).encode()
        logger.debug(f"Login. Data after: {data_encoded}")
        self._catch_error_request(self.url + 'login.php', data_encoded)
        if self.error:
            return
        logger.debug(f"That we have: {[cookie for cookie in mcj]}")
        if 'bb_session' in [cookie.name for cookie in mcj]:
            mcj.save(FILE_C, ignore_discard=True, ignore_expires=True)
            logger.info("We successfully authorized")
        else:
            self.error = "We not authorized, please check your credentials!"
            logger.warning(self.error)
Esempio n. 18
0
    def __request__(self):

        Cookiejar = CookieJar()
        opener = build_opener(HTTPCookieProcessor(Cookiejar))
        _header = dict(self.headers.items())
        if self.cookie:
            _header.update({'Cookie': self.cookie})
        req = Request(self.url, headers=_header, origin_req_host=self.host)

        res = None

        try:
            res = opener.open(req)
            # break
        except HTTPError as e:
            # if e.code >= 400 and e.code < 500:
            return e, None

        except (socket.timeout, URLError) as e:
            return e, None
        except Exception as e:
            traceback.print_exc()
            return e, None

        return res, Cookiejar._cookies
Esempio n. 19
0
    def web_bruter(self):
        while not self.password_q.empty() and not self.found:
            brute = self.password_q.get().rstrip()
            jar = cookielib.FileCookieJar("cookies")
            opener = request.build_opener(HTTPCookieProcessor(jar))

            response = opener.open(target_url)

            page = response.read()

            print("Trying: %s : %s (%d left)" % (self.username, brute, self.password_q.qsize()))

            # parse out the hidden fields
            parser = BruteParser()
            parser.feed(page)

            post_tags = parser.tar_results

            # add our username and password fields
            post_tags[username_field] = self.username
            post_tags[password_field] = brute

            login_data = urlencode(post_tags)
            login_response = opener.open(target_post, login_data)

            login_result = login_response.read()

            if success_check in login_result:
                self.found = True
                print("[*] Bruteforce successful.")
                print("[*] Username: %s" % username)
                print("[*] Password: %s" % brute)
                print("[*] Waiting for other threads to exit...")
Esempio n. 20
0
    def login(self, mcj):
        if self.error:
            return None
        # if we wanna use https we mast add ssl=enable_ssl to cookie
        mcj.set_cookie(Cookie(0, "ssl", "enable_ssl", None, False,
                              ".nnmclub.to", True, False, "/", True,
                              False, None, False, None, None, {}))
        self.session.add_handler(HTTPCookieProcessor(mcj))

        response = self._catch_error_request(self.url_login)
        if not response:
            return None
        code = RE_CODE.search(response.decode('cp1251'))[1]
        form_data = {"username": config['username'],
                     "password": config['password'],
                     "autologin": "******",
                     "code": code,
                     "login": "******"}
        # so we first encode vals to cp1251 then do default decode whole string
        data_encoded = urlencode(
            {k: v.encode('cp1251') for k, v in form_data.items()}
        ).encode()

        self._catch_error_request(self.url_login, data_encoded)
        if self.error:
            return None
        logger.debug(f"That we have: {[cookie for cookie in mcj]}")
        if 'phpbb2mysql_4_sid' in [cookie.name for cookie in mcj]:
            mcj.save(FILE_C, ignore_discard=True, ignore_expires=True)
            logger.info('We successfully authorized')
        else:
            self.error = "We not authorized, please check your credentials!"
            logger.warning(self.error)
Esempio n. 21
0
def register(first_name, last_name, email, password):
    # get register page
    url = 'http://example.webscraping.com/places/default/user/register'
    cj = CookieJar()
    opener = build_opener(HTTPCookieProcessor(cj))
    html = opener.open(url).read()

    # try recognize captcha
    img = get_captcha(html)
    gray = img.convert('L')
    bw = gray.point(lambda x: x if x < 1 else 255, '1')
    captcha = pytesseract.image_to_string(bw)

    # parse form and fill
    form = parse_form(html)
    form['first_name'] = first_name
    form['last_name'] = last_name
    form['email'] = email
    form['password'] = password
    form['password_two'] = password
    form['recaptcha_response_field'] = captcha

    data = urlencode(form).encode('utf-8')
    r = Request(url=url, data=data)
    register_page = opener.open(r)
    return '/user/register' not in register_page.geturl()
Esempio n. 22
0
def auth(*, email, password, client_id, scope):
    def split_key_value(kv_pair):
        kv = kv_pair.split("=")
        return kv[0], kv[1]

    # Authorization form
    def auth_user(email, password, client_id, scope, opener):
        response = opener.open(
            "http://oauth.vk.com/oauth/authorize?" + \
            "redirect_uri=http://oauth.vk.com/blank.html&response_type=token&" + \
            "client_id=%s&scope=%s" % (client_id, ",".join(scope))
            )
        doc = response.read().decode('utf-8')
        parser = AuthFormParser()
        parser.feed(doc)
        parser.close()
        if not parser.form_parsed or parser.url is None or "pass" not in parser.params or \
          "email" not in parser.params:
            raise RuntimeError("Something wrong")
        parser.params["email"] = email
        parser.params["pass"] = password
        if parser.method == "POST":
            response = opener.open(parser.url,
                                   urlencode(parser.params).encode('ascii'))
        else:
            raise NotImplementedError("Method '%s'" % parser.method)
        return response.read(), response.geturl()

    # Permission request form
    def give_access(doc, opener):
        parser = AuthFormParser()
        parser.feed(doc)
        parser.close()
        if not parser.form_parsed or parser.url is None:
            raise RuntimeError("Something wrong")
        if parser.method == "POST":
            response = opener.open(parser.url,
                                   urlencode(parser.params).encode('ascii'))
        else:
            raise NotImplementedError("Method '%s'" % parser.method)
        return response.geturl()

    if not isinstance(scope, list):
        scope = [scope]
    opener = build_opener(HTTPCookieProcessor(http.cookiejar.CookieJar()),
                          HTTPRedirectHandler())
    doc, url = auth_user(email, password, client_id, scope, opener)
    if urlparse(url).path != "/blank.html":
        # Need to give access to requested scope
        url = give_access(doc.decode('utf-8'), opener)
    if urlparse(url).path != "/blank.html":
        raise RuntimeError("Expected success here")
    answer = dict(
        split_key_value(kv_pair)
        for kv_pair in urlparse(url).fragment.split("&"))
    if "access_token" not in answer or "user_id" not in answer:
        raise RuntimeError("Missing some values in answer")

    return answer["access_token"], answer["user_id"]
Esempio n. 23
0
 def _setup_cookies(self):
     # all requests should use the same cookie jar
     self.cookiejar = LWPCookieJar(self.cookiefile)
     if os.path.isfile(self.cookiefile):
         self.cookiejar.load(ignore_discard=True)
     self.cookieprocessor = HTTPCookieProcessor(self.cookiejar)
     self.opener = build_opener(self.cookieprocessor)
     install_opener(self.opener)
Esempio n. 24
0
 def __init__(self):
     socket.setdefaulttimeout(20)
     cookie = HTTPCookieProcessor(CookieJar())
     opener = build_opener(cookie, HTTPHandler)
     install_opener(opener)
     agent = random.choice(AGENT)
     opener.addheaders = [("User-agent", agent), ("Accept", "*/*")]
     self.opener = opener
Esempio n. 25
0
    def __init__(self, auth_token, base_url):
        self._token = auth_token
        self._burl = base_url

        # These object attributes are used to allow authentifying only once for
        # the whole lifetime of the object.
        self._cookie_processor = HTTPCookieProcessor(CookieJar())
        self._authentified = False
Esempio n. 26
0
 def __init__(self, proxy=""):
     # 生成cookie池
     self.cookie = http.cookiejar.CookieJar()
     self.opener = urllib.request.build_opener(
         HTTPCookieProcessor(self.cookie))
     if proxy:
         # proxy format '127.0.0.1:8087'
         # self.p = urllib2.ProxyHandler({'http': proxy})
         # self.proxy_opener = urllib2.build_opener(self.p)
         self.opener = urllib.request.build_opener(
             HTTPCookieProcessor(self.cookie), ProxyHandler({'http':
                                                             proxy}))
     urllib.request.install_opener(self.opener)
     self.headers = {
         'User-Agent':
         'Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.1.6) Gecko/20091201 Firefox/3.5.6'
     }
Esempio n. 27
0
 def nse_opener(self):
     """
     builds opener for urllib2
     :return: opener object
     """
     cj = CookieJar()
     bo = build_opener(HTTPCookieProcessor(cj))
     return bo
Esempio n. 28
0
 def setup_method(self, method):
     self.cookies = CookieJar()
     self.opener = build_opener(HTTPRedirectHandler(),
                                HTTPHandler(debuglevel=0),
                                HTTPSHandler(debuglevel=0),
                                HTTPCookieProcessor(self.cookies))
     self.application_process = Process(target=main)
     self.application_process.start()
Esempio n. 29
0
 def __init__(self):
     self.loginUrl = '****************'
     self.cookies = http.cookiejar.CookieJar()
     self.postdata = urlencode({
         "txtId":"*********",
         "txtMM":"*&******"
     }).encode(encoding='gbk')
     self.opener = build_opener(HTTPCookieProcessor(self.cookies))
Esempio n. 30
0
def __opener__():
    """
    Builds the opener for the url
    :returns: opener object
    """

    cookie_jar = CookieJar()
    return build_opener(HTTPCookieProcessor(cookie_jar))