Update docstrings to include return types for autocomplet

Author: mvantellingen

Diff for: src/zeep/client.py

@@ -15,6 +15,12 @@ def __init__(self, service_proxy, operation_name):
         self._op_name = operation_name
 
     def __call__(self, *args, **kwargs):
+        """Call the operation with the given args and kwargs.
+
+        :rtype: zeep.xsd.CompoundValue
+
+        """
+
         if self._proxy._client._default_soapheaders:
             op_soapheaders = kwargs.get('_soapheaders')
             if op_soapheaders:
@@ -42,9 +48,19 @@ def __init__(self, client, binding, **binding_options):
         self._binding = binding
 
     def __getattr__(self, key):
+        """Return the OperationProxy for the given key.
+
+        :rtype: OperationProxy
+
+        """
         return self[key]
 
     def __getitem__(self, key):
+        """Return the OperationProxy for the given key.
+
+        :rtype: OperationProxy
+
+        """
         try:
             self._binding.get(key)
         except ValueError:
@@ -62,9 +78,19 @@ def __init__(self, types, kind, namespace):
             self._ns = types.get_ns_prefix(namespace)
 
     def __getattr__(self, key):
+        """Return the complexType or simpleType for the given localname.
+
+        :rtype: zeep.xsd.ComplexType or zeep.xsd.AnySimpleType
+
+        """
         return self[key]
 
     def __getitem__(self, key):
+        """Return the complexType or simpleType for the given localname.
+
+        :rtype: zeep.xsd.ComplexType or zeep.xsd.AnySimpleType
+
+        """
         return self._method('{%s}%s' % (self._ns, key))
 
 
@@ -102,7 +128,11 @@ def __init__(self, wsdl, wsse=None, transport=None,
 
     @property
     def service(self):
-        """The default ServiceProxy instance"""
+        """The default ServiceProxy instance
+
+        :rtype: ServiceProxy
+
+        """
         if self._default_service:
             return self._default_service
 
@@ -182,15 +212,25 @@ def type_factory(self, namespace):
             factory = client.type_factory('ns0')
             user = factory.User(name='John')
 
+        :rtype: Factory
+
         """
         return Factory(self.wsdl.types, 'type', namespace)
 
     def get_type(self, name):
-        """Return the type for the given qualified name."""
+        """Return the type for the given qualified name.
+
+        :rtype: zeep.xsd.ComplexType or zeep.xsd.AnySimpleType
+
+        """
         return self.wsdl.types.get_type(name)
 
     def get_element(self, name):
-        """Return the element for the given qualified name."""
+        """Return the element for the given qualified name.
+
+        :rtype: zeep.xsd.Element
+
+        """
         return self.wsdl.types.get_element(name)
 
     def set_ns_prefix(self, prefix, namespace):

Diff for: src/zeep/xsd/schema.py

@@ -63,14 +63,22 @@ def namespaces(self):
 
     @property
     def elements(self):
-        """Yield all globla xsd.Type objects"""
+        """Yield all globla xsd.Type objects
+
+        :rtype: Iterable of zeep.xsd.Element
+
+        """
         for document in self.documents:
             for element in document._elements.values():
                 yield element
 
     @property
     def types(self):
-        """Yield all globla xsd.Type objects"""
+        """Yield all global xsd.Type objects
+
+        :rtype: Iterable of zeep.xsd.ComplexType
+
+        """
         for document in self.documents:
             for type_ in document._types.values():
                 yield type_
@@ -94,12 +102,20 @@ def add_documents(self, schema_nodes, location):
         self._prefix_map_auto = self._create_prefix_map()
 
     def get_element(self, qname):
-        """Return a global xsd.Element object with the given qname"""
+        """Return a global xsd.Element object with the given qname
+
+        :rtype: zeep.xsd.Group
+
+        """
         qname = self._create_qname(qname)
         return self._get_instance(qname, 'get_element', 'element')
 
     def get_type(self, qname, fail_silently=False):
-        """Return a global xsd.Type object with the given qname"""
+        """Return a global xsd.Type object with the given qname
+
+        :rtype: zeep.xsd.ComplexType or zeep.xsd.AnySimpleType
+
+        """
         qname = self._create_qname(qname)
         try:
             return self._get_instance(qname, 'get_type', 'type')
@@ -110,15 +126,27 @@ def get_type(self, qname, fail_silently=False):
                 raise
 
     def get_group(self, qname):
-        """Return a global xsd.Group object with the given qname"""
+        """Return a global xsd.Group object with the given qname.
+
+        :rtype: zeep.xsd.Group
+
+        """
         return self._get_instance(qname, 'get_group', 'group')
 
     def get_attribute(self, qname):
-        """Return a global xsd.attributeGroup object with the given qname"""
+        """Return a global xsd.attributeGroup object with the given qname
+
+        :rtype: zeep.xsd.Attribute
+
+        """
         return self._get_instance(qname, 'get_attribute', 'attribute')
 
     def get_attribute_group(self, qname):
-        """Return a global xsd.attributeGroup object with the given qname"""
+        """Return a global xsd.attributeGroup object with the given qname
+
+        :rtype: zeep.xsd.AttributeGroup
+
+        """
         return self._get_instance(qname, 'get_attribute_group', 'attributeGroup')
 
     def set_ns_prefix(self, prefix, namespace):
@@ -201,6 +229,8 @@ def _create_qname(self, name):
 
         This also expands the shorthand notation.
 
+        :rtype: lxml.etree.QNaame
+
         """
         if isinstance(name, etree.QName):
             return name
@@ -231,6 +261,11 @@ def _create_prefix_map(self):
         return prefix_map
 
     def _has_schema_document(self, namespace):
+        """Return a boolean if there is a SchemaDocumnet for the namespace.
+
+        :rtype: boolean
+
+        """
         return namespace in self._documents
 
     def _add_schema_document(self, document):
@@ -239,11 +274,22 @@ def _add_schema_document(self, document):
         documents.append(document)
 
     def _get_schema_document(self, namespace, location):
+        """Return a list of SchemaDocument's for the given namespace AND
+        location.
+
+        :rtype: SchemaDocument
+
+        """
         for document in self._documents.get(namespace, []):
             if document._location == location:
                 return document
 
     def _get_schema_documents(self, namespace, fail_silently=False):
+        """Return a list of SchemaDocument's for the given namespace.
+
+        :rtype: list of SchemaDocument
+
+        """
         if namespace not in self._documents:
             if fail_silently:
                 return []
@@ -370,23 +416,43 @@ def register_attribute_group(self, name, value):
         self._attribute_groups[name] = value
 
     def get_type(self, qname):
-        """Return a xsd.Type object from this schema"""
+        """Return a xsd.Type object from this schema
+
+        :rtype: zeep.xsd.ComplexType or zeep.xsd.AnySimpleType
+
+        """
         return self._get_instance(qname, self._types, 'type')
 
     def get_element(self, qname):
-        """Return a xsd.Element object from this schema"""
+        """Return a xsd.Element object from this schema
+
+        :rtype: zeep.xsd.Element
+
+        """
         return self._get_instance(qname, self._elements, 'element')
 
     def get_group(self, qname):
-        """Return a xsd.Group object from this schema"""
+        """Return a xsd.Group object from this schema.
+
+        :rtype: zeep.xsd.Group
+
+        """
         return self._get_instance(qname, self._groups, 'group')
 
     def get_attribute(self, qname):
-        """Return a xsd.Attribute object from this schema"""
+        """Return a xsd.Attribute object from this schema
+
+        :rtype: zeep.xsd.Attribute
+
+        """
         return self._get_instance(qname, self._attributes, 'attribute')
 
     def get_attribute_group(self, qname):
-        """Return a xsd.AttributeGroup object from this schema"""
+        """Return a xsd.AttributeGroup object from this schema
+
+        :rtype: zeep.xsd.AttributeGroup
+
+        """
         return self._get_instance(qname, self._attribute_groups, 'attributeGroup')
 
     def _get_instance(self, qname, items, item_name):

Diff for: src/zeep/xsd/valueobjects.py

@@ -34,6 +34,7 @@ def xsd_elm(self):
 
 
 class CompoundValue(object):
+    """Represents a data object for a specific xsd:complexType."""
 
     def __init__(self, *args, **kwargs):
         values = OrderedDict()