Python Session.verify方法代码示例

# 需要导入模块: from requests import Session [as 别名]
# 或者: from requests.Session import verify [as 别名]
def download_linke(coords, proxy, port, saveFile, saveMode):

    print proxy, port
    print proxy != ""

    url = "http://www.soda-is.com/eng/services/service_invoke/gui.php?" + "xml_descript=soda_tl.xml&Submit2=Month"

    session = Session()
    session.verify = False

    if proxy != "":
        proxies = {proxy: port}
        session.proxies = proxies

    br = RoboBrowser(session=session, parser="lxml")
    br.open(url)

    linke_form = br.get_forms()[1]

    num = len(coords)
    index = 0

    with open(saveFile, saveMode) as f:
        try:
            for coord in coords:
                inlon, inlat = coord
                linke_form["lat"].value = inlat
                linke_form["lon"].value = inlon

                sf = linke_form.submit_fields.getlist("execute")
                br.submit_form(linke_form, submit=sf[0])

                linke_table = br.find("table", {"cellspacing": "0", "cellpadding": "2"})

                linkes = get_monthly_linke_str(get_linke_values(linke_table))
                s = "%s,%s,%s\n" % (format(inlon, "0.5f"), format(inlat, "0.5f"), linkes)

                if len(s) > 48:
                    f.write(s)
                    print "Done with point %i of %i: (%s, %s)" % (
                        index + 1,
                        num,
                        format(inlon, "0.5f"),
                        format(inlat, "0.5f"),
                    )

                index += 1

                br.back()

            print "DONE!"

        except Exception as e:

            not_dl = list(coords[index:])
            with open(saveFile + "_notdownloaded.txt", "w") as nd:
                for c in not_dl:
                    nd.write("%s,%s\n" % (str(c[0]), str(c[1])))
            print e

# 需要导入模块: from requests import Session [as 别名]
# 或者: from requests.Session import verify [as 别名]
def consulta_distribuicao_nfe(certificado, **kwargs):
    if "xml" not in kwargs:
        kwargs['xml'] = xml_consulta_distribuicao_nfe(certificado, **kwargs)
    xml_send = kwargs["xml"]
    base_url = localizar_url(
        'NFeDistribuicaoDFe',  kwargs['estado'], kwargs['modelo'],
        kwargs['ambiente'])

    cert, key = extract_cert_and_key_from_pfx(
        certificado.pfx, certificado.password)
    cert, key = save_cert_key(cert, key)

    session = Session()
    session.cert = (cert, key)
    session.verify = False
    transport = Transport(session=session)

    xml = etree.fromstring(xml_send)
    xml_um = etree.fromstring('<nfeCabecMsg xmlns="http://www.portalfiscal.inf.br/nfe/wsdl/"><cUF>AN</cUF><versaoDados>1.00</versaoDados></nfeCabecMsg>')
    client = Client(base_url, transport=transport)

    port = next(iter(client.wsdl.port_types))
    first_operation = next(iter(client.wsdl.port_types[port].operations))
    with client.settings(raw_response=True):
        response = client.service[first_operation](nfeDadosMsg=xml, _soapheaders=[xml_um])
        response, obj = sanitize_response(response.text)
        return {
            'sent_xml': xml_send,
            'received_xml': response,
            'object': obj.Body.nfeDistDFeInteresseResponse.nfeDistDFeInteresseResult
        }

# 需要导入模块: from requests import Session [as 别名]
# 或者: from requests.Session import verify [as 别名]
    def __init__(self, name, plex_url, plex_user, plex_password,
                 plex_server, plex_token, verify_ssl):
        """Initialize the sensor."""
        from plexapi.myplex import MyPlexAccount
        from plexapi.server import PlexServer
        from requests import Session

        self._name = name
        self._state = 0
        self._now_playing = []

        cert_session = None
        if not verify_ssl:
            _LOGGER.info("Ignoring SSL verification")
            cert_session = Session()
            cert_session.verify = False

        if plex_token:
            self._server = PlexServer(plex_url, plex_token, cert_session)
        elif plex_user and plex_password:
            user = MyPlexAccount(plex_user, plex_password)
            server = plex_server if plex_server else user.resources()[0].name
            self._server = user.resource(server).connect()
        else:
            self._server = PlexServer(plex_url, None, cert_session)

# 需要导入模块: from requests import Session [as 别名]
# 或者: from requests.Session import verify [as 别名]
 def __init__(self, logger):
     """Initialize browser instance."""
     session = Session()
     session.verify = False
     self.logger = logger
     self.browser = robobrowser.RoboBrowser(
         session=session, parser='html.parser', timeout=50)

# 需要导入模块: from requests import Session [as 别名]
# 或者: from requests.Session import verify [as 别名]
    def __init__(self, env, id_correios, password,
                 cert=False, log_config=None, timeout=None):
        ''' Webservice initialization.

        Depending on the env get a different wsdl definition.
        New Correios SIGEP uses HTTPAuth to do requests.

        Args:
            env (str): Environment used to get the wsdl
            id_correios (str): IdCorreios given by correios website
            password (str): password vinculated to the IdCorreios
            log_config (dict): Dictionary configurations of logging
        '''

        ''' Untrusted ssl certificate for homolog envs see more at:

        https://www.ssllabs.com/ssltest/analyze.html?d=apphom.correios.com.br
        '''
        if cert is False:
            verify = False
        else:
            verify = certifi.where()

        self.timeout = timeout or 300

        if log_config is not None and isinstance(log_config, dict):
            """ Example config from zeep documentation:

            {
                'version': 1,
                'formatters': {
                    'verbose': {
                        'format': '%(name)s: %(message)s'
                    }
                },
                'handlers': {
                    'console': {
                        'level': 'DEBUG',
                        'class': 'logging.StreamHandler',
                        'formatter': 'verbose',
                    },
                },
                'loggers': {
                    'zeep.transports': {
                        'level': 'DEBUG',
                        'propagate': True,
                        'handlers': ['console'],
                    },
                }
            }
            """
            logging.config.dictConfig(log_config)

        session = Session()
        session.timeout = self.timeout
        session.verify = verify
        session.auth=(id_correios, password)

        t = Transport(session=session);
        self.client = Client(wsdl=self.get_env(env), transport=t)

# 需要导入模块: from requests import Session [as 别名]
# 或者: from requests.Session import verify [as 别名]
def start_crawl(pages=2):
    session = Session()
    session.verify = False
    url = 'https://www.sgs.gov.cn/notice/search/ent_except_list'
    b = RoboBrowser(session=session)
    b.open(url)

    basic_info = pd.DataFrame(columns=['name', 'url', 'ID', 'date'])
    detail_info = pd.DataFrame()
    for i in range(pages):  # 改变这个数字控制爬取页数, 网页限制最大５０页
        form = b.get_form(id='formInfo')
        if not form:
            continue
        form['condition.pageNo'].value = str(i + 1)  # 修改表单控制页数
        form['condition.keyword'].value = ''
        try:  # dirty fix...
            b.submit_form(form)
            basic_info = basic_info.append(parse_table(b), ignore_index=True)
        except AttributeError:
            pass

    for url in basic_info['url']:
        detail = get_detail(url)
        if isinstance(detail, pd.DataFrame):
            detail_info = detail_info.append(detail, ignore_index=True)

    return basic_info, detail_info

# 需要导入模块: from requests import Session [as 别名]
# 或者: from requests.Session import verify [as 别名]
 def get_estatus(self, data):
     data['emisor_rfc'] = escape(data['emisor_rfc'])
     data['receptor_rfc'] = escape(data['receptor_rfc'])
     data = self._soap.format(**data).encode('utf-8')
     headers = {
         'SOAPAction': '"http://tempuri.org/IConsultaCFDIService/Consulta"',
         'Content-length': len(data),
         'Content-type': 'text/xml; charset="UTF-8"'
     }
     s = Session()
     s.verify = False
     req = Request('POST', self._webservice, data=data, headers=headers)
     prepped = req.prepare()
     try:
         response = s.send(prepped, timeout=5)
         res = xml2dict.parse(response.text)
         ok, res = self._check_fault(res)
         if ok:
             return False
         self.msg = res['ConsultaResponse']['ConsultaResult']['a:Estado']
         return True
     except exceptions.Timeout:
         self.error = 'Tiempo de espera agotado'
     except Exception as e:
         print (e)
     return False

# 需要导入模块: from requests import Session [as 别名]
# 或者: from requests.Session import verify [as 别名]
def _send(certificado, method, **kwargs):
    xml_send = kwargs["xml"]
    base_url = localizar_url(
        method,  kwargs['estado'], kwargs['modelo'], kwargs['ambiente'])

    cert, key = extract_cert_and_key_from_pfx(
        certificado.pfx, certificado.password)
    cert, key = save_cert_key(cert, key)

    session = Session()
    session.cert = (cert, key)
    session.verify = False
    transport = Transport(session=session)

    xml = etree.fromstring(xml_send)
    client = Client(base_url, transport=transport)

    port = next(iter(client.wsdl.port_types))
    first_operation = next(iter(client.wsdl.port_types[port].operations))
    
    namespaceNFe = xml.find(".//{http://www.portalfiscal.inf.br/nfe}NFe")
    if namespaceNFe is not None:
        namespaceNFe.set('xmlns', 'http://www.portalfiscal.inf.br/nfe')
            
    with client.settings(raw_response=True):
        response = client.service[first_operation](xml)
        response, obj = sanitize_response(response.text)
        return {
            'sent_xml': xml_send,
            'received_xml': response,
            'object': obj.Body.getchildren()[0]
        }

# 需要导入模块: from requests import Session [as 别名]
# 或者: from requests.Session import verify [as 别名]
 def create_session(self, alias, headers=None, auth=None, verify="False", cert=None):
     session = Session()
     if headers:
         session.headers.update(headers)
     if auth:
         session.auth = tuple(auth)
     session.verify = self._builtin.convert_to_boolean(verify)
     session.cert = cert
     self._cache.register(session, alias)

# 需要导入模块: from requests import Session [as 别名]
# 或者: from requests.Session import verify [as 别名]
def https():
    uri = 'https://localhost:8443/' + os.environ.get('TEST_TARGET', '')
    s = Session()
    s.cert = (cert_path, key_path)
    s.headers.update({'user': 'testuser'})
    s.verify = cacert_path
    r = s.get(uri)
    print("TARGET:      {}".format(uri))
    print("STATUS_CODE: {}".format(r.status_code))
    print("TEXT:        {}".format(r.text))

# 需要导入模块: from requests import Session [as 别名]
# 或者: from requests.Session import verify [as 别名]
    def _setup_session(self):
        s = Session()
        if 'verify' in self.settings:  # default is True
            s.verify = self.settings['verify']
        if 'trust_env' in self.settings:
            s.trust_env = self.settings['trust_env']
        if self._auth is not None:
            s.auth = self._auth

        s.headers = merge_setting(  # add our headers to requests' default set
            self._headers, s.headers, dict_class=CaseInsensitiveDict)

        return s

# 需要导入模块: from requests import Session [as 别名]
# 或者: from requests.Session import verify [as 别名]
    def __init__(self, wsdl, cert=None, verify=True, timeout=8, **kwargs):
        session = Session()
        session.cert = cert
        session.verify = verify
        session.timeout = timeout
        session.headers.update({'Content-Type': 'text/xml;charset=UTF-8'})

        transport = Transport(
            operation_timeout=timeout,
            session=session
        )

        super().__init__(wsdl=wsdl, transport=transport, **kwargs)

# 需要导入模块: from requests import Session [as 别名]
# 或者: from requests.Session import verify [as 别名]
    def _get_environments(self):
        data = {}
        try:
            session = Session()
            session.verify = False
            response = session.get(settings.ENVIRONMENT_URL)

            response.raise_for_status()

            data = response.json()

        except ConnectionError as e:
            logger.critical('{}'.format(e))
        except (ValueError, HTTPError) as e:
            logger.error('{}'.format(e))

        return data

# 需要导入模块: from requests import Session [as 别名]
# 或者: from requests.Session import verify [as 别名]
    def create_soap_client(self, alias, wsdl=None, endpoint=None):
        """
        Creates SOAP client with specified alias.

        Arguments:
        | alias | client alias |
        | wsdl | path or url to service wsdl |
        | endpoint | url for service under test |

        Example usage:
        | Create Soap Client | client_alias | wsdl=path_to_wsdl${/}ws_example.wsdl | endpoint=http://localhost:8080/ |
        """
        session = Session()
        session.verify = False
        if wsdl:
            wsdl = self._get_wsdl(session, wsdl)
        client = SOAPClient(session, wsdl, endpoint)
        self._cache.register(client, alias)

# 需要导入模块: from requests import Session [as 别名]
# 或者: from requests.Session import verify [as 别名]
    def create_rest_session(self, alias, headers=None, auth=None, verify=False, cert=None):
        """
        Creates REST session with specified alias.

        Arguments:
        | alias | session alias |
        | headers | custom headers for all requests |
        | auth | basic auth |
        | verify | SSL verification |
        | cert | path to SSL certificate file |

        Example usage:
        | ${headers} | Create Dictionary | Content-Type | application/json |
        | @{service_basic_auth} | Set Variable | username | password |
        | Create Rest Session | session_alias | headers=${headers} | auth=${service_basic_auth} | verify=False |
        """
        session = Session()
        if headers:
            session.headers.update(headers)
        if auth:
            session.auth = tuple(auth)
        session.verify = self._builtin.convert_to_boolean(verify)
        session.cert = cert
        self._cache.register(session, alias)