Get the soap:binding.
331593
def soaproot(self):
        """"""
        for ns in (soapns, soap12ns):
            sr = self.root.getChild("binding", ns=ns)
            if sr is not None:
                return sr
478742
def soap_request(self, url, urn, action, params, body_elem="m"):
        """"""
        soap_body = (
            '<?xml version="1.0" encoding="utf-8"?>'
            '<s:Envelope xmlns:s="http://schemas.xmlsoap.org/soap/envelope/"'
            ' s:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/">'
            '<s:Body>'
            '<{body_elem}:{action} xmlns:{body_elem}="urn:{urn}">'
            '{params}'
            '</{body_elem}:{action}>'
            '</s:Body>'
            '</s:Envelope>'
        ).format(action=action, urn=urn, params=params, body_elem=body_elem).encode('utf-8')

        headers = {
            'Host': '{}:{}'.format(self._host, self._port),
            'Content-Length': len(soap_body),
            'Content-Type': 'text/xml; charset=utf-8"',
            'SOAPAction': '"urn:{}#{}"'.format(urn, action),
        }

        url = 'http://{}:{}/{}'.format(self._host, self._port, url)

        _LOGGER.debug("Sending to %s:\n%s\n%s", url, headers, soap_body)
        req = Request(url, soap_body, headers)

        res = urlopen(req, timeout=5).read()
        _LOGGER.debug("Response: %s", res)
        return res
859465
private function getSoapClient()
    {
        if (null === $this->soapClient) {
            $this->soapClient = new \SoapClient(
                $this->wsdl,
                array(
                    'classmap' => $this->classmap,
                    'user_agent' => 'Mozilla', // the request fails unless a (dummy) user agent is specified
                    'exceptions' => true,
                )
            );
        }

        return $this->soapClient;
    }
1295731
private static Method getBindingMethod(UIComponent parent)
    {
        Class[] clazzes = parent.getClass().getInterfaces();

        for (int i = 0; i < clazzes.length; i++)
        {
            Class clazz = clazzes[i];

            if(clazz.getName().indexOf("BindingAware")!=-1)
            {
                try
                {
                    return  parent.getClass().getMethod("handleBindings",new Class[]{});
                }
                catch (NoSuchMethodException e)
                {
                    // return
                }
            }
        }

        return null;
    }
741478
public static Document getSoapBody(Document soapMessage) throws Exception {
        Element envelope = soapMessage.getDocumentElement();
        Element body = DomUtils.getChildElement(DomUtils.getElementByTagName(
                envelope, envelope.getPrefix() + ":Body"));
        Document content = DomUtils.createDocument(body);

        Element documentRoot = content.getDocumentElement();
        addNSdeclarations(envelope, documentRoot);
        addNSdeclarations(body, documentRoot);
        return content;
    }
1011442
protected function getSoapClient()
    {
      if(!isset($this->wsdl))
        throw new Exception(__METHOD__ .'; No WSDL set');
        
      if(!(is_null($this->client) && $this->client instanceof SoapClient))
        $this->client = new SoapClient($this->wsdl);
          
      return $this->client;
    }
1136128
def parse_authn_query_response(self, response, binding=BINDING_SOAP):
        
        kwargs = {"entity_id": self.config.entityid,
                  "attribute_converters": self.config.attribute_converters}

        return self._parse_response(response, AuthnQueryResponse, "", binding,
                                    **kwargs)
1288083
public static tmglobal_binding get(nitro_service service) throws Exception{
		tmglobal_binding obj = new tmglobal_binding();
		tmglobal_binding response = (tmglobal_binding) obj.get_resource(service);
		return response;
	}
587345
def get_object(conn, binding_name, object_cls):
        
        try:
            obj = conn.rootContext.resolve(binding_name)
            narrowed = obj._narrow(object_cls)
        except CORBA.TRANSIENT:
            raise IOError('Attempt to retrieve object failed')

        if narrowed is None:
            raise IOError('Attempt to retrieve object got a different class of object')

        return narrowed
64313
public static server_service_binding[] get(nitro_service service, String name) throws Exception{
		server_service_binding obj = new server_service_binding();
		obj.set_name(name);
		server_service_binding response[] = (server_service_binding[]) obj.get_resources(service);
		return response;
	}
855754
def get_state(self) -> str:
        """"""
        xdoc = self.connection.soap_action('/ws/ControllerService',
                                           'getState', "")
        if xdoc:
            return xdoc.find('./SOAP-ENV:Body/ns1:getState1/ns1:state',
                             IHCSoapClient.ihcns).text
        return False
75649
def soap_attribute(self, name, value):
        
        setattr(self, name, value)
        self._attributes.add(name)
762370
def getPortType(self):
        """"""
        wsdl = self.getService().getWSDL()
        binding = wsdl.bindings[self.binding]
        return wsdl.portTypes[binding.type]
621178
def _GetBindingNamespace(self):
    """"""
    return (list(self.zeep_client.wsdl.bindings.itervalues())[0]
            .port_name.namespace)
458579
protected function getSoap()
    {
        if ($this->SOAPClient === null) {
            $this->SOAPClient = new \SoapClient($this->url,
                [
                    'trace' => 1,
                    'cache_wsdl' => WSDL_CACHE_NONE
                ]);
            if ($this->location) {
                $this->SOAPClient->__setLocation($this->location);
            }
        }
        return $this->SOAPClient;
    }
869142
public Bindings getBindings(String attribute) {
	if (_bindings == null || attribute == null) return null;
	return (Bindings)_bindings.get(canonicalize(attribute));
    }
20210
def do_resolve(self, definitions):
        
        filtered = []
        for p in self.ports:
            ref = qualify(p.binding, self.root, definitions.tns)
            binding = definitions.bindings.get(ref)
            if binding is None:
                raise Exception("binding '%s', not-found" % (p.binding,))
            if binding.soap is None:
                log.debug("binding '%s' - not a SOAP binding, discarded",
                    binding.name)
                continue
            # After we have been resolved, our caller will expect that the
            # binding we are referencing has been fully constructed, i.e.
            # resolved, as well. The only scenario where the operations binding
            # might possibly not have already resolved its references, and
            # where this explicit resolve() call is required, is if we are
            # dealing with a recursive WSDL import chain.
            binding.resolve(definitions)
            p.binding = binding
            filtered.append(p)
        self.ports = filtered