title: Cython cdef Class not displaying doc string or __init__ parameters
body: <p>I have used cdef to define a python class which wraps a C++ class with Cython and it works correctly. However when I use help(class) in python or class? in ipython I get something like the following:</p>
  
  <pre><code>&gt;&gt;&gt; TestClass.CTestClass?
  Init signature: TestClass.CTestClass()
  Docstring:      &lt;no docstring&gt;
  File:               ~/Coding/CythonWithCppTutorials/ClassCythonCPPWithMemberFunctions/TestClass.so
  Type:           type
  </code></pre>
  
  <p>Which does not display any doc-string or init signature, which I would like to have displayed, how could I get it to display this?</p>
  
  <p>The Cython wrapper is as follows:</p>
  
  <p>TestClass.pyx</p>
  
  <pre><code>import cython
  import numpy as np
  cimport numpy as np
  
  cdef extern from "TestClassC.cpp": # defines the source C++ file
      cdef cppclass TestClass: # says that there is a class defined in the above C++ file called TestClass
          TestClass(int Dimensionality, double* InputArray) # the class has public member function TestClass which takes some arguments
          double SumListOfNumbers() # the class has a public member function which returns a double and has no arguments
          int Dimensionality # the class has a public variable that is an integer and is called Dimensionality
          double* ListOfNumbers # the class has another public variable that is a pointer to a double
  
  cdef class CTestClass: # defines a python wrapper to the C++ class
      """
      This is a test class wrapper for c++.
      """
      cdef TestClass* thisptr # thisptr is a pointer that will hold to the instance of the C++ class
      def __cinit__(self, int Dimensionality, np.ndarray[double, ndim=1, mode="c"] InputArray not None): # defines the python wrapper class' init function
          cdef double[::1] InputArrayC = InputArray # defines a memoryview containnig a 1D numpy array - this can be passed as a C-like array by providing a pointer to the 1st element and the length
          self.thisptr = new TestClass(Dimensionality, &amp;InputArrayC[0]) # creates an instance of the C++ class and puts allocates the pointer to this
      def __dealloc__(self): # defines the python wrapper class' deallocation function (python destructor)
          del self.thisptr # destroys the reference to the C++ instance (which calls the C++ class destructor
      def CSumListOfNumbers(self):
          return self.thisptr.SumListOfNumbers()
  </code></pre>
  
  <p>and the C++ code looks like so:</p>
  
  <p>TestClassC.cpp</p>
  
  <pre><code>#include &lt;iostream&gt;
  
  class TestClass{
  public:
    TestClass(int Dimensionality, double* InputArray); // prototype of constructor
    ~TestClass(void); // prototype of destructor
    double SumListOfNumbers(void);
    int Dimensionality;
    double* ListOfNumbers;
  };
  
  TestClass::TestClass(int DIM, double* InputArray)
  {
    Dimensionality = DIM;
    std::cout &lt;&lt; Dimensionality &lt;&lt; "\n";
    ListOfNumbers = new double[Dimensionality];
    for (int i = 0; i &lt; Dimensionality; ++i) {
      ListOfNumbers[i] = InputArray[i];
      std::cout &lt;&lt; ListOfNumbers[i] &lt;&lt; ", ";
    }
    std::cout &lt;&lt; "\n";
  };
  
  TestClass::~TestClass(void){
    std::cout &lt;&lt; "Being Destroyed" &lt;&lt; "\n";
  };
  
  double TestClass::SumListOfNumbers(void){
    double Sum = 0;
    for (int i = 0; i &lt; Dimensionality; ++i) {
      Sum += ListOfNumbers[i];
    }
    return Sum;
  }
  </code></pre>