Update binding generation

cppwg/input/base_info.py

@@ -1,89 +1,139 @@
-"""
-Generic information structure for packages, modules and cpp types
-"""
+from typing import Any, Dict, List, Optional
 
 
-class BaseInfo(object):
-
+class BaseInfo:
     """
-    :param: name - the feature name, as it appears in its definition
-    :param: source_includes - a list of source files to be included with the feature
-    :param: calldef_excludes - do not include calldefs matching these patterns
-    :param: smart_ptr_type - handle classes with this smart pointer type
-    :param: template_substitutions - a list of template substitution sequences
-    :param: pointer_call_policy - the default pointer call policy
-    :param: reference_call_policy - the default reference call policy
-    :param: extra_code - any extra wrapper code for the feature
-    :param: prefix_code - any wrapper code that precedes the feature
-    :param: excluded_methods - do not include these methods
-    :param: excluded_variables - do not include these variables
-    :param: constructor_arg_type_excludes - list of exlude patterns for ctors
-    :param: return_type_exludes - list of exlude patterns for return types
-    :param: arg_type_excludes - list of exlude patterns for arg types 
+    Generic information structure for features (i.e packages, modules, classes,
+    free functions, etc.)
+
+    Attributes
+    ----------
+    name : str
+        The feature name, as it appears in its definition.
+    source_includes : List[str]
+        A list of source files to be included with the feature.
+    calldef_excludes : List[str]
+        Do not include calldefs matching these patterns.
+    smart_ptr_type : str, optional
+        Handle classes with this smart pointer type.
+    template_substitutions : Dict[str, List[Any]]
+        A list of template substitution sequences.
+    pointer_call_policy : str, optional
+        The default pointer call policy.
+    reference_call_policy : str, optional
+        The default reference call policy.
+    extra_code : List[str]
+        Any extra wrapper code for the feature.
+    prefix_code : List[str]
+        Any wrapper code that precedes the feature.
+    custom_generator : str, optional
+        A custom generator for the feature.
+    excluded_methods : List[str]
+        Do not include these methods.
+    excluded_variables : List[str]
+        Do not include these variables.
+    constructor_arg_type_excludes : List[str]
+        List of exclude patterns for ctors.
+    return_type_excludes : List[str]
+        List of exclude patterns for return types.
+    arg_type_excludes : List[str]
+        List of exclude patterns for arg types.
+    name_replacements : Dict[str, str]
+        A dictionary of name replacements e.g. {"double":"Double", "unsigned int":"Unsigned"}
     """
 
     def __init__(self, name):
-
-        self.name = name
-        self.source_includes = []
-        self.calldef_excludes = []
-        self.smart_ptr_type = None
-        self.template_substitutions = []  
-        self.pointer_call_policy = None
-        self.reference_call_policy = None
-        self.extra_code = []
-        self.prefix_code = []
-        self.custom_generator = None
-        self.excluded_methods = None
-        self.excluded_variables = None
-        self.constructor_arg_type_excludes = []
-        self.return_type_excludes = []
-        self.arg_type_excludes = []
-        self.name_replacements = {"double": "Double",
-                                  "unsigned int": "Unsigned",
-                                  "Unsigned int": "Unsigned",
-                                  "unsigned": "Unsigned",
-                                  "double": "Double",
-                                  "std::vector": "Vector",
-                                  "std::pair": "Pair",
-                                  "std::map": "Map",
-                                  "std::string": "String",
-                                  "boost::shared_ptr": "SharedPtr",
-                                  "*": "Ptr",
-                                  "c_vector": "CVector",
-                                  "std::set": "Set"}
-
+        self.name: str = name
+        self.source_includes: List[str] = []
+        self.calldef_excludes: List[str] = []
+        self.smart_ptr_type: Optional[str] = None
+        self.template_substitutions: Dict[str, List[Any]] = []
+        self.pointer_call_policy: Optional[str] = None
+        self.reference_call_policy: Optional[str] = None
+        self.extra_code: List[str] = []
+        self.prefix_code: List[str] = []
+        self.custom_generator: Optional[str] = None
+        self.excluded_methods: List[str] = []
+        self.excluded_variables: List[str] = []
+        self.constructor_arg_type_excludes: List[str] = []
+        self.return_type_excludes: List[str] = []
+        self.arg_type_excludes: List[str] = []
+        self.name_replacements: Dict[str, str] = {
+            "double": "Double",
+            "unsigned int": "Unsigned",
+            "Unsigned int": "Unsigned",
+            "unsigned": "Unsigned",
+            "double": "Double",
+            "std::vector": "Vector",
+            "std::pair": "Pair",
+            "std::map": "Map",
+            "std::string": "String",
+            "boost::shared_ptr": "SharedPtr",
+            "*": "Ptr",
+            "c_vector": "CVector",
+            "std::set": "Set",
+        }
+
     @property
-    def parent(self):
+    def parent(self) -> Optional["BaseInfo"]:
+        """
+        Return the parent object of the feature in the hierarchy. This is
+        overriden in subclasses e.g. ModuleInfo returns a PackageInfo, ClassInfo
+        returns a ModuleInfo, etc.
+
+        Returns
+        -------
+        Optional[BaseInfo]
+            The parent object.
+        """
         return None
-
-    def hierarchy_attribute(self, attribute_name):
-
+
+    def hierarchy_attribute(self, attribute_name: str) -> Any:
         """
-        For the supplied attribute iterate through parents until a non None
-        value is found. If the tope level parent attribute is None, return None.
+        For the supplied attribute, iterate through parent objects until a non-None
+        value is found. If the top level parent (i.e. package) attribute is
+        None, return None.
+
+        Parameters
+        ----------
+        attribute_name : str
+            The attribute name to search for.
+
+        Returns
+        -------
+        Any
+            The attribute value.
         """
-        
+
         if hasattr(self, attribute_name) and getattr(self, attribute_name) is not None:
             return getattr(self, attribute_name)
-        else:
-            if hasattr(self, 'parent') and self.parent is not None: 
-                return self.parent.hierarchy_attribute(attribute_name)   
-            else:
-                return None
-
-    def hierarchy_attribute_gather(self, attribute_name):
-
+
+        if hasattr(self, "parent") and self.parent is not None:
+            return self.parent.hierarchy_attribute(attribute_name)
+
+        return None
+
+    def hierarchy_attribute_gather(self, attribute_name: str) -> List[Any]:
         """
-        For the supplied attribute iterate through parents gathering list entries.
+        For the supplied attribute, iterate through parent objects gathering list entries.
+
+        Parameters
+        ----------
+        attribute_name : str
+            The attribute name to search for.
+
+        Returns
+        -------
+        List[Any]
+            The list of attribute values.
         """
-
-        att_list = []
+
+        att_list: List[Any] = []
+
         if hasattr(self, attribute_name) and getattr(self, attribute_name) is not None:
             att_list.extend(getattr(self, attribute_name))
-            if hasattr(self, 'parent') and self.parent is not None: 
-                att_list.extend(self.parent.hierarchy_attribute_gather(attribute_name)) 
-        else:
-            if hasattr(self, 'parent') and self.parent is not None: 
-                att_list.extend(self.parent.hierarchy_attribute_gather(attribute_name))             
-        return att_list               
+
+        if hasattr(self, "parent") and self.parent is not None:
+            att_list.extend(self.parent.hierarchy_attribute_gather(attribute_name))
+
+        return att_list

cppwg/input/class_info.py

@@ -1,17 +1,20 @@
-"""
-Information structure common to C++ classes
-"""
+from typing import Any, Dict, Optional
 
-from cppwg.input import cpp_type_info
+from cppwg.input.cpp_type_info import CppTypeInfo
 
 
-class CppClassInfo(cpp_type_info.CppTypeInfo):
+class CppClassInfo(CppTypeInfo):
+    """
+    This class holds information for individual C++ classes to be wrapped
+    """
 
+    def __init__(self, name: str, class_config: Optional[Dict[str, Any]] = None):
+
+        super(CppClassInfo, self).__init__(name, class_config)
 
-    def __init__(self, name, type_info_dict = None):
-
-        super(CppClassInfo, self).__init__(name, type_info_dict)
-
     @property
-    def parent(self):
+    def parent(self) -> "ModuleInfo":
+        """
+        Returns the parent module info object
+        """
         return self.module_info