Wrap Update

python/CMakeLists.txt

@@ -92,7 +92,7 @@ set_target_properties(${GTSAM_PYTHON_TARGET} PROPERTIES
 set(GTSAM_MODULE_PATH ${GTSAM_PYTHON_BUILD_DIRECTORY}/gtsam)
 
 # Symlink all tests .py files to build folder.
-create_symlinks("${CMAKE_CURRENT_SOURCE_DIR}/gtsam"
+copy_directory("${CMAKE_CURRENT_SOURCE_DIR}/gtsam"
         "${GTSAM_MODULE_PATH}")
 
 # Common directory for data/datasets stored with the package.
@@ -148,7 +148,7 @@ if(GTSAM_UNSTABLE_BUILD_PYTHON)
     set(GTSAM_UNSTABLE_MODULE_PATH ${GTSAM_PYTHON_BUILD_DIRECTORY}/gtsam_unstable)
 
     # Symlink all tests .py files to build folder.
-    create_symlinks("${CMAKE_CURRENT_SOURCE_DIR}/gtsam_unstable"
+    copy_directory("${CMAKE_CURRENT_SOURCE_DIR}/gtsam_unstable"
             "${GTSAM_UNSTABLE_MODULE_PATH}")
 
     # Add gtsam_unstable to the install target

wrap/.github/workflows/macos-ci.yml

@@ -27,10 +27,12 @@ jobs:
 
       - name: Python Dependencies
         run: |
+          pip3 install -U pip setuptools
           pip3 install -r requirements.txt
 
       - name: Build and Test
         run: |
+          # Build
           cmake .
           cd tests
           # Use Pytest to run all the tests.

wrap/cmake/PybindWrap.cmake

@@ -192,9 +192,9 @@ function(install_python_files source_files dest_directory)
 endfunction()
 
 # ~~~
-# https://stackoverflow.com/questions/13959434/cmake-out-of-source-build-python-files
+# Copy over the directory from source_folder to dest_foler
 # ~~~
-function(create_symlinks source_folder dest_folder)
+function(copy_directory source_folder dest_folder)
   if(${source_folder} STREQUAL ${dest_folder})
     return()
   endif()
@@ -215,31 +215,13 @@ function(create_symlinks source_folder dest_folder)
     # Create REAL folder
     file(MAKE_DIRECTORY "${dest_folder}")
 
-    # Delete symlink if it exists
+    # Delete if it exists
     file(REMOVE "${dest_folder}/${path_file}")
 
-    # Get OS dependent path to use in `execute_process`
-    file(TO_NATIVE_PATH "${dest_folder}/${path_file}" link)
+    # Get OS dependent path to use in copy
     file(TO_NATIVE_PATH "${source_folder}/${path_file}" target)
 
-    # cmake-format: off
-    if(UNIX)
-      set(command ln -s ${target} ${link})
-    else()
-      set(command cmd.exe /c mklink ${link} ${target})
-    endif()
-    # cmake-format: on
-
-    execute_process(
-      COMMAND ${command}
-      RESULT_VARIABLE result
-      ERROR_VARIABLE output)
-
-    if(NOT ${result} EQUAL 0)
-      message(
-        FATAL_ERROR
-          "Could not create symbolic link for: ${target} --> ${output}")
-    endif()
+    file(COPY ${target} DESTINATION ${dest_folder})
 
   endforeach(path_file)
-endfunction(create_symlinks)
+endfunction(copy_directory)

wrap/gtwrap/interface_parser/classes.py

@@ -62,6 +62,10 @@ def __init__(self,
 
         self.parent = parent
 
+    def to_cpp(self) -> str:
+        """Generate the C++ code for wrapping."""
+        return self.name
+
     def __repr__(self) -> str:
         return "Method: {} {} {}({}){}".format(
             self.template,
@@ -84,24 +88,27 @@ class Hello {
     ```
     """
     rule = (
-        STATIC  #
+        Optional(Template.rule("template"))  #
+        + STATIC  #
         + ReturnType.rule("return_type")  #
         + IDENT("name")  #
         + LPAREN  #
         + ArgumentList.rule("args_list")  #
         + RPAREN  #
         + SEMI_COLON  # BR
     ).setParseAction(
-        lambda t: StaticMethod(t.name, t.return_type, t.args_list))
+        lambda t: StaticMethod(t.name, t.return_type, t.args_list, t.template))
 
     def __init__(self,
                  name: str,
                  return_type: ReturnType,
                  args: ArgumentList,
+                 template: Union[Template, Any] = None,
                  parent: Union["Class", Any] = ''):
         self.name = name
         self.return_type = return_type
         self.args = args
+        self.template = template
 
         self.parent = parent
 
@@ -221,8 +228,8 @@ class Members:
         Rule for all the members within a class.
         """
         rule = ZeroOrMore(Constructor.rule  #
-                          ^ StaticMethod.rule  #
                           ^ Method.rule  #
+                          ^ StaticMethod.rule  #
                           ^ Variable.rule  #
                           ^ Operator.rule  #
                           ^ Enum.rule  #

wrap/gtwrap/interface_parser/type.py

@@ -158,6 +158,8 @@ class Type:
     """
     Parsed datatype, can be either a fundamental type or a custom datatype.
     E.g. void, double, size_t, Matrix.
+    Think of this as a high-level type which encodes the typename and other 
+    characteristics of the type.
 
     The type can optionally be a raw pointer, shared pointer or reference.
     Can also be optionally qualified with a `const`, e.g. `const int`.
@@ -240,6 +242,9 @@ def to_cpp(self, use_boost: bool) -> str:
              or self.typename.name in ["Matrix", "Vector"]) else "",
             typename=typename))
 
+    def get_typename(self):
+        """Convenience method to get the typename of this type."""
+        return self.typename.name
 
 class TemplatedType:
     """

wrap/gtwrap/matlab_wrapper/mixins.py

@@ -112,7 +112,7 @@ def _format_type_name(self,
 
         if separator == "::":  # C++
             templates = []
-            for idx in range(len(type_name.instantiations)):
+            for idx, _ in enumerate(type_name.instantiations):
                 template = '{}'.format(
                     self._format_type_name(type_name.instantiations[idx],
                                            include_namespace=include_namespace,
@@ -124,7 +124,7 @@ def _format_type_name(self,
                 formatted_type_name += '<{}>'.format(','.join(templates))
 
         else:
-            for idx in range(len(type_name.instantiations)):
+            for idx, _ in enumerate(type_name.instantiations):
                 formatted_type_name += '{}'.format(
                     self._format_type_name(type_name.instantiations[idx],
                                            separator=separator,

wrap/gtwrap/pybind_wrapper.py

@@ -119,8 +119,11 @@ def _wrap_method(self,
         if py_method in self.python_keywords:
             py_method = py_method + "_"
 
-        is_method = isinstance(method, instantiator.InstantiatedMethod)
-        is_static = isinstance(method, parser.StaticMethod)
+        is_method = isinstance(
+            method, (parser.Method, instantiator.InstantiatedMethod))
+        is_static = isinstance(
+            method,
+            (parser.StaticMethod, instantiator.InstantiatedStaticMethod))
         return_void = method.return_type.is_void()
         args_names = method.args.names()
         py_args_names = self._py_args_names(method.args)