def headpart_types(self, method, input=True):
     """
     Get a list of I{parameter definitions} (pdef) defined for the specified method.
     Each I{pdef} is a tuple (I{name}, L{xsd.sxbase.SchemaObject})
     @param method: A service method.
     @type method: I{service.Method}
     @param input: Defines input/output message.
     @type input: boolean
     @return:  A list of parameter definitions
     @rtype: [I{pdef},]
     """
     result = []
     if input:
         headers = method.soap.input.headers
     else:
         headers = method.soap.output.headers
     for header in headers:
         part = header.part
         if part.element is not None:
             query = ElementQuery(part.element)
         else:
             query = TypeQuery(part.type)
         pt = query.execute(self.schema())
         if pt is None:
             raise TypeNotFound(query.ref)
         if part.type is not None:
             pt = PartElement(part.name, pt)
         if input:
             if pt.name is None:
                 result.append((part.name, pt))
             else:
                 result.append((pt.name, pt))
         else:
             result.append(pt)
     return result

 def bodypart_types(method, schema, input=True):
     """
     This returns the types of a soap body.
     This is basically copied from the suds source code (suds.bindings.binding)
     """
     result = []
     if input:
         parts = method.soap.input.body.parts
     else:
         parts = method.soap.output.body.parts
     for p in parts:
         if p.element is not None:
             query = ElementQuery(p.element)
         else:
             query = TypeQuery(p.type)
         pt = query.execute(schema)
         if pt is None:
             raise TypeNotFound(query.ref)
         if p.type is not None:
             pt = TypeNotFound(p.name, pt)
         if input:
             if pt.name is None:
                 result.append((p.name, pt))
             else:
                 result.append((pt.name, pt))
         else:
             result.append(pt)
     return result

    def marshal_exception(self, exc, method):

        raise NotImplementedError("cannot yet handle exceptions")

        # The following code is very much unfinished and there is no
        # guaranty that it is correct or even makes sense
        # Currently it finds the fault return types (there should only
        # be one AFAICT). How to get from there and to to a fault body
        # is still open.

        from suds import TypeNotFound
        from suds.bindings.binding import PartElement
        from suds.xsd.query import TypeQuery, ElementQuery

        rtypes = []

        for f in method.unwrapped_.soap.faults:
            for p in f.parts:
                if p.element is not None:
                    query = ElementQuery(p.element)
                else:
                    query = TypeQuery(p.type)
                pt = query.execute(method.binding.output.schema())
                if pt is None:
                    raise TypeNotFound(query.ref)
                if p.type is not None:
                    pt = PartElement(p.name, pt)
                rtypes.append(pt)

        return rtypes

 def dependencies(self):
     deps = []
     midx = None
     if self.ref is not None:
         query = ElementQuery(self.ref)
         e = query.execute(self.schema)
         if e is None:
             log.debug(self.schema)
             raise TypeNotFound(self.ref)
         deps.append(e)
         midx = 0
     return (midx, deps)

 def set_wrapped(self):
     """ set (wrapped|bare) flag on messages """
     for b in list(self.bindings.values()):
         for op in list(b.operations.values()):
             for body in (op.soap.input.body, op.soap.output.body):
                 body.wrapped = False
                 if len(body.parts) != 1:
                     continue
                 for p in body.parts:
                     if p.element is None:
                         continue
                     query = ElementQuery(p.element)
                     pt = query.execute(self.schema)
                     if pt is None:
                         raise TypeNotFound(query.ref)
                     resolved = pt.resolve()
                     if resolved.builtin():
                         continue
                     body.wrapped = True