Cython cdef Class not displaying doc string or __i

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:

>>> TestClass.CTestClass?
Init signature: TestClass.CTestClass()
Docstring:      <no docstring>
File:               ~/Coding/CythonWithCppTutorials/ClassCythonCPPWithMemberFunctions/TestClass.so
Type:           type

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?

The Cython wrapper is as follows:

TestClass.pyx

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, &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()

and the C++ code looks like so:

TestClassC.cpp

#include <iostream>

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 << Dimensionality << "\n";
  ListOfNumbers = new double[Dimensionality];
  for (int i = 0; i < Dimensionality; ++i) {
    ListOfNumbers[i] = InputArray[i];
    std::cout << ListOfNumbers[i] << ", ";
  }
  std::cout << "\n";
};

TestClass::~TestClass(void){
  std::cout << "Being Destroyed" << "\n";
};

double TestClass::SumListOfNumbers(void){
  double Sum = 0;
  for (int i = 0; i < Dimensionality; ++i) {
    Sum += ListOfNumbers[i];
  }
  return Sum;
}

The way to solve this was to do as was suggested by oz1 and set the embedsignature directive to True and also to add a normal python __init__ function like so:

@cython.embedsignature(True)
cdef class CTestClass: # defines a python wrapper to the C++ class
    """
    This is a test class wrapper for c++.
    """
    def __init__(self, Dimensionality, InputArray):
        pass

    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, &InputArrayC[0]) # creates an instance of the C++ class and puts allocates the pointer to this

Then the init signature is included in the docstring automatically like so:

In [1]: import TestClass

In [2]: TestClass.CTestClass?
Init signature: TestClass.CTestClass(self, /, *args, **kwargs)
Docstring:
CTestClass(Dimensionality, InputArray)

This is a test class wrapper for c++.
File:           ~/Coding/CythonWithCppTutorials/ClassCythonCPPWithMemberFunctions/TestClass.so
Type:           type