This method finds all SOAP Binding Operations, it will skip 
        all bindings that are not SOAP.  
        item -- WSDL.Binding instance
338766
def setUp(self, item):
        '''
        '''
        assert isinstance(item, WSDLTools.Binding), \
              'expecting WSDLTools Binding instance'

        portType = item.getPortType()
        self._kwargs = KW.copy()
        self._kwargs['bind'] = NC_to_CN(item.name)
        self.operations = []
        self.rProp = portType.getResourceProperties() 
        soap_binding = item.findBinding(WSDLTools.SoapBinding)
        if soap_binding is None:
            raise Wsdl2PythonError,\
                'Binding(%s) missing WSDLTools.SoapBinding' %item.name

        for bop in item.operations:
            soap_bop = bop.findBinding(WSDLTools.SoapOperationBinding)
            if soap_bop is None:
                self.logger.warning(\
                    'Skip Binding(%s) operation(%s) no SOAP Binding Operation'\
                    %(item.name, bop.name),
                )
                continue

            #soapAction = soap_bop.soapAction
            if bop.input is not None:
                soapBodyBind = bop.input.findBinding(WSDLTools.SoapBodyBinding)
                if soapBodyBind is None:
                    self.logger.warning(\
                        'Skip Binding(%s) operation(%s) Bindings(%s) not supported'\
                        %(item.name, bop.name, bop.extensions)
                    )
                    continue
                
            op = portType.operations.get(bop.name)
            if op is None:
                raise Wsdl2PythonError,\
                    'no matching portType/Binding operation(%s)' % bop.name
                    
            c = self.operationclass(useWSA=self.useWSA, 
                    do_extended=self.do_extended)
            c.setUp(bop)
            self.operations.append(c)
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
243117
public static List<CommerceWishListItem> toModels(
		CommerceWishListItemSoap[] soapModels) {
		if (soapModels == null) {
			return null;
		}

		List<CommerceWishListItem> models = new ArrayList<CommerceWishListItem>(soapModels.length);

		for (CommerceWishListItemSoap soapModel : soapModels) {
			models.add(toModel(soapModel));
		}

		return models;
	}
331593
def soaproot(self):
        """"""
        for ns in (soapns, soap12ns):
            sr = self.root.getChild("binding", ns=ns)
            if sr is not None:
                return sr
72567
def skip(self, ns):
        
        return ns in (None, Namespace.default, Namespace.xsdns, Namespace.xsins, Namespace.xmlns)
101885
def _WsdlHasMethod(self, method_name):
    
    return method_name in self.suds_client.wsdl.services[0].ports[0].methods
688717
def soap(func=None, name=None, returns=None, args=None, doc=None, target='SOAP'):
    
    global __soap_functions__
    
    returns = _fix_soap_kwargs(returns)
    args = _fix_soap_kwargs(args)
    
    if isinstance(func, str) and not name:
        return partial(soap, name=func, returns=returns, args=args, doc=doc, target=target)
    
    if not func:
        return partial(soap, name=name, returns=returns, args=args, doc=doc, target=target)

    target_functions = __soap_functions__.setdefault(target, {})
    if inspect.isfunction(func):
        f_name = func.__name__
        if name:
            f_name = name
        target_functions[f_name] = endpoint = ('.'.join([func.__module__, func.__name__]), returns, args, doc)
        func.soap_endpoint = (f_name, endpoint)
    elif inspect.isclass(func):
        if not name:
            name = func.__name__
        for _name in dir(func):
            f = getattr(func, _name)
            if (inspect.ismethod(f) or inspect.isfunction(f)) and not _name.startswith('_'):
                f_name = name + '.' + f.__name__
                endpoint = ('.'.join([func.__module__, func.__name__, _name]), returns, args, doc)
                if hasattr(f, 'soap_endpoint'):
                    #the method has already been decorate by soap 
                    _n, _e = f.soap_endpoint
                    target_functions[name + '.' + _n] = endpoint
                    del target_functions[_n]
                else:
                    target_functions[f_name] = endpoint
    else:
        raise Exception("Can't support this type [%r]" % func)
    return func
1028533
function preProcessBindings(bindingString) {
  var results = [];
  var bindingHandlers = this.bindingHandlers;
  var preprocessed;

  // Check for a Provider.preprocessNode property
  if (typeof this.preprocessNode === 'function') {
    preprocessed = this.preprocessNode(bindingString, this);
    if (preprocessed) { bindingString = preprocessed; }
  }

  for (var i = 0, j = this.bindingPreProcessors.length; i < j; ++i) {
    preprocessed = this.bindingPreProcessors[i](bindingString, this);
    if (preprocessed) { bindingString = preprocessed; }
  }

  function addBinding(name, value) {
    results.push("'" + name + "':" + value);
  }

  function processBinding(key, value) {
    // Get the "on" binding from "on.click"
    var handler = bindingHandlers.get(key.split('.')[0]);

    if (handler && typeof handler.preprocess === 'function') {
      value = handler.preprocess(value, key, processBinding);
    }

    addBinding(key, value);
  }

  arrayForEach(parseObjectLiteral(bindingString), function(keyValueItem) {
    processBinding(
      keyValueItem.key || keyValueItem.unknown,
      keyValueItem.value
    );
  });

  return results.join(',');
}
486250
def get_soap_object(self, client):
        
        def to_soap_attribute(attr):
            words = attr.split('_')
            words = words[:1] + [word.capitalize() for word in words[1:]]
            return ''.join(words)

        soap_object = client.factory.create(self.soap_name)
        for attr in self._attributes:
            value = getattr(self, attr)
            setattr(soap_object, to_soap_attribute(attr), value)

        return soap_object
524167
@Override
  public BindingProvider createSoapClient(SoapServiceDescriptor soapServiceDescriptor)
      throws ServiceException {
    try {
      if (soapServiceDescriptor instanceof JaxWsCompatible) {
        JaxWsCompatible jaxWsCompatibleService = (JaxWsCompatible) soapServiceDescriptor;
        Object portLocator = jaxWsCompatibleService.getServiceClass()
            .getConstructor(new Class[0]).newInstance(new Object[0]);
        String interfaceClassName = soapServiceDescriptor.getInterfaceClass().getSimpleName();
        BindingProvider soapClient = (BindingProvider) portLocator.getClass()
            .getMethod("get" + interfaceClassName + "Port").invoke(portLocator);

        // Required for App Engine to avoid default 10s timeout for UrlFetch requests.
        setConnectTimeout(soapClient);

        @SuppressWarnings("rawtypes") // getHandlerChain returns a list of raw Handler.
        List<Handler> bindings = soapClient.getBinding().getHandlerChain();
        bindings.add(contextHandlerProvider.get());
        soapClient.getBinding().setHandlerChain(bindings);
        return soapClient;
      }
      throw new ServiceException(
          "Service [" + soapServiceDescriptor + "] is not compatible with JAX-WS", null);
    } catch (SecurityException e) {
      throw new ServiceException("Unexpected Exception.", e);
    } catch (NoSuchMethodException e) {
      throw new ServiceException("Unexpected Exception.", e);
    } catch (IllegalArgumentException e) {
      throw new ServiceException("Unexpected Exception.", e);
    } catch (IllegalAccessException e) {
      throw new ServiceException("Unexpected Exception.", e);
    } catch (InvocationTargetException e) {
      throw new ServiceException("Unexpected Exception.", e.getCause());
    } catch (ClassNotFoundException e) {
      throw new ServiceException("Unexpected Exception.", e);
    } catch (InstantiationException e) {
      throw new ServiceException("Unexpected Exception.", e);
    }
  }
192513
protected List<Item> doFilter(List<Item> items, ItemFilter filter, boolean runningBeforeProcessing) {
        List<Item> acceptedItems = new ArrayList<>();
        List<Item> rejectedItems = new ArrayList<>();

        for (Item item : items) {
            if (filter.accepts(item, acceptedItems, rejectedItems, runningBeforeProcessing)) {
                acceptedItems.add(item);
            } else {
                rejectedItems.add(item);
            }
        }

        if (logger.isDebugEnabled()) {
            logger.debug("Items filtered from " + items + " by " + filter + ": " + acceptedItems);
        }

        return acceptedItems;
    }
1075435
private static function getAllSoapActions( DOMDocument $wsdlDocument, $serviceName ) {
        /* Find the selected Service definition from the WSDL */
        $selectedServiceNode = null;
        foreach ( $wsdlDocument->getElementsByTagName( 'service' ) as $serviceNode ) {
            if ( $serviceNode->hasAttribute( 'name' ) && $serviceNode->getAttribute( 'name' ) == $serviceName ) {
                $selectedServiceNode = $serviceNode;
                break;
            }
        }
        if ( $selectedServiceNode == null ) {
            throw new Exception( 'Could not find definition of Service <' . $serviceName . '> in provided WSDL' );
        }
        /* Now find the Binding for the Service */
        $bindingName = null;
        foreach ( $selectedServiceNode->getElementsByTagName( 'port' ) as $portNode ) {
            if ( $portNode->hasAttribute( 'name' ) ) {
                $bindingName = $portNode->getAttribute( 'name' );
                break;
            }
        }
        if ( $bindingName == null ) {
            throw new Exception( 'Could not find binding for Service <' . $serviceName . '> in provided WSDL' );
        }
        /* Find the Binding definition from the WSDL */
        $bindingNode = null;
        foreach ( $wsdlDocument->getElementsByTagName( 'binding' ) as $bindingNode ) {
            if ( $bindingNode->hasAttribute( 'name' ) && $bindingNode->getAttribute( 'name' ) == $bindingName ) {
                break;
            }
        }
        if ( $bindingNode == null ) {
            throw new Exception( 'Could not find defintion of Binding <' . $bindingName . '> in provided WSDL' );
        }
        /* Array to store the list of Operations and SoapActions */
        $operationArray = Array();
        /* Find the Operations */
        foreach ( $bindingNode->getElementsByTagName( 'operation' ) as $operationNode ) {
            if ( $operationNode->hasAttribute( 'name' ) ) {
                /* Record the Name of this Operation */
                $operationName = $operationNode->getAttribute( 'name' );
                /* Find the Operation SoapAction from the WSDL */
                foreach ( $operationNode->getElementsByTagName( 'operation' ) as $soap12OperationNode ) {
                    if ( $soap12OperationNode->hasAttribute( 'soapAction' ) ) {
                        /* Record the SoapAction for this Operation */
                        $soapAction = $soap12OperationNode->getAttribute( 'soapAction' );
                        /* Store the soapAction in the Array */
                        $operationArray[ $operationName ] = $soapAction;
                    }
                }
                unset( $soap12OperationNode );
            }
        }

        /* Return the array of available actions */

        return $operationArray;
    }
292517
def class_instances_from_soap_enveloped_saml_thingies(text, modules):
    
    try:
        envelope = defusedxml.ElementTree.fromstring(text)
    except Exception as exc:
        raise XmlParseError("%s" % exc)

    assert envelope.tag == '{%s}Envelope' % soapenv.NAMESPACE
    assert len(envelope) >= 1
    env = {"header": [], "body": None}

    for part in envelope:
        if part.tag == '{%s}Body' % soapenv.NAMESPACE:
            assert len(part) == 1
            env["body"] = instanciate_class(part[0], modules)
        elif part.tag == "{%s}Header" % soapenv.NAMESPACE:
            for item in part:
                env["header"].append(instanciate_class(item, modules))

    return env
107057
def skip(self, attr):
        
        ns = attr.namespace()
        skip = (
            Namespace.xmlns[1],
            'http://schemas.xmlsoap.org/soap/encoding/',
            'http://schemas.xmlsoap.org/soap/envelope/',
            'http://www.w3.org/2003/05/soap-envelope',
        )
        return ( Namespace.xs(ns) or ns[1] in skip )
736375
private void _buildNotBinding(
                    final NotBinding binding,
                    final StringBuilder stmt,
                    final List<Object> params
                    )
    {
        stmt.append( " NOT (" );
        _buildBinding( binding, stmt, params );
        stmt.append( ")" );
    }
1181955
def array name, values
      array_attrs = {
        'soapenc:arrayType' => "xsd:string[#{values.length}]",
        'xsi:type'          => 'wsdl:ArrayOfString'
      }
      builder.tag! name, array_attrs do |tag|
        values.each { |value| tag.item value }
      end
      self
    end
303070
def getItemTrace(self):
        
        item, path, name, ref = self, [], 'name', 'ref'
        while not isinstance(item,XMLSchema) and not isinstance(item,WSDLToolsAdapter):
            attr = item.getAttribute(name)
            if not attr:
                attr = item.getAttribute(ref)
                if not attr:
                    path.append('<%s>' %(item.tag))
                else: 
                    path.append('<%s ref="%s">' %(item.tag, attr))
            else:
                path.append('<%s name="%s">' %(item.tag,attr))

            item = item._parent()
        try:
            tns = item.getTargetNamespace()
        except: 
            tns = ''
        path.append('<%s targetNamespace="%s">' %(item.tag, tns))
        path.reverse()
        return ''.join(path)