try to disambiguate C attribute and method

2 files changed, 67 insertions, 65 deletions

diff --git a/pyisda/credit_index.pxd b/pyisda/credit_index.pxd
index 0cf8cf8..56267f9 100644
--- a/pyisda/credit_index.pxd
+++ b/pyisda/credit_index.pxd
@@ -7,14 +7,14 @@ from libcpp.string cimport string
 
 cdef class CurveList:
     cdef TDate base_date
-    cdef vector[double] weights
+    cdef vector[double] _weights
     cdef vector[double] T
-    cdef vector[shared_ptr[TCurve]] curves
+    cdef vector[shared_ptr[TCurve]] _curves
     cdef unordered_map[string, size_t] tickers
     cdef vector[shared_ptr[double]] recovery_rates
 
 cdef class CreditIndex(CurveList):
     cdef TDate start_date
-    cdef vector[TDate] maturities
+    cdef vector[TDate] _maturities
     cdef TContingentLeg** contingent_legs
     cdef TFeeLeg** fee_legs
diff --git a/pyisda/credit_index.pyx b/pyisda/credit_index.pyx
index d13a8e9..3238f2f 100644
--- a/pyisda/credit_index.pyx
+++ b/pyisda/credit_index.pyx
@@ -43,6 +43,7 @@ cdef TContingentLeg* copyContingentLeg(TContingentLeg* leg) nogil:
     memcpy(new_leg, leg, sizeof(TContingentLeg))
     return new_leg
 
+@cython.auto_pickle(False)
 cdef class CurveList:
 
     @cython.initializedcheck(False)
@@ -69,22 +70,22 @@ cdef class CurveList:
             if it == self.tickers.end():
                 self.tickers[sc.ticker] = i
                 if sc is not None:
-                    self.curves.push_back(sc._thisptr)
+                    self._curves.push_back(sc._thisptr)
                     self.recovery_rates.push_back(sc.recovery_rates)
                 else:
-                    self.curves.push_back(shared_ptr[TCurve]())
+                    self._curves.push_back(shared_ptr[TCurve]())
                     self.recovery_rates.push_back(shared_ptr[double]())
-                self.weights.push_back(1.)
+                self._weights.push_back(1.)
                 i += 1
             else:
-                self.weights[deref(it).second] += 1
+                self._weights[deref(it).second] += 1
 
         if weights is not None:
             for i in range(weights.shape[0]):
-                self.weights[i] = weights[i]
+                self._weights[i] = weights[i]
         else:
-            for i in range(self.curves.size()):
-                self.weights[i] /= n
+            for i in range(self._curves.size()):
+                self._weights[i] /= n
 
     def __getitem__(self, str ticker):
         cdef:
@@ -97,7 +98,7 @@ cdef class CurveList:
             raise KeyError(ticker)
         else:
             sc = SpreadCurve.__new__(SpreadCurve)
-            sc._thisptr = self.curves[deref(got).second]
+            sc._thisptr = self._curves[deref(got).second]
             sc.recovery_rates = self.recovery_rates[deref(got).second]
             sc.ticker = ticker_cpp
             return sc
@@ -110,16 +111,16 @@ cdef class CurveList:
 
         for p in self.tickers:
             sc = SpreadCurve.__new__(SpreadCurve)
-            sc._thisptr = self.curves[p.second]
+            sc._thisptr = self._curves[p.second]
             sc.ticker = p.first
             sc.recovery_rates = self.recovery_rates[p.second]
-            yield (sc.ticker.decode(), self.weights[p.second], sc)
+            yield (sc.ticker.decode(), self._weights[p.second], sc)
 
     @property
     def weights(self):
-        cdef np.npy_intp shape = self.weights.size()
+        cdef np.npy_intp shape = self._weights.size()
         cdef np.ndarray out =  \
-                    np.PyArray_SimpleNewFromData(1, &shape, np.NPY_DOUBLE, self.weights.data())
+                    np.PyArray_SimpleNewFromData(1, &shape, np.NPY_DOUBLE, self._weights.data())
         out.base = <PyObject*>self
         Py_INCREF(self)
         return out
@@ -136,7 +137,7 @@ cdef class CurveList:
 
         for p in self.tickers:
             sc = SpreadCurve.__new__(SpreadCurve)
-            sc._thisptr = self.curves[p.second]
+            sc._thisptr = self._curves[p.second]
             sc.ticker = p.first
             sc.recovery_rates = self.recovery_rates[p.second]
             r.append(sc)
@@ -150,9 +151,9 @@ cdef class CurveList:
             SpreadCurve sc
             unordered_map[string, size_t].iterator it
 
-        self.curves.clear()
+        self._curves.clear()
         self.tickers.clear()
-        self.weights.clear()
+        self._weights.clear()
 
         sc = l[0]
         self.T.resize(sc._thisptr.get().fNumItems)
@@ -167,16 +168,16 @@ cdef class CurveList:
             if it == self.tickers.end():
                 self.tickers[sc.ticker] = i
                 if sc is not None:
-                    self.curves.push_back(sc._thisptr)
+                    self._curves.push_back(sc._thisptr)
                 else:
-                    self.curves.push_back(shared_ptr[TCurve]())
-                self.weights.push_back(1.)
+                    self._curves.push_back(shared_ptr[TCurve]())
+                self._weights.push_back(1.)
                 i += 1
             else:
-                self.weights[deref(it).second] += 1
+                self._weights[deref(it).second] += 1
 
-        for i in range(self.curves.size()):
-            self.weights[i] /= len_l
+        for i in range(self._curves.size()):
+            self._weights[i] /= len_l
 
     def __deepcopy__(self, memo):
         cdef:
@@ -185,13 +186,13 @@ cdef class CurveList:
             size_t i = 0
             TCurve* copy_sc
             CurveList copy = CurveList.__new__(CurveList)
-        copy.weights = self.weights
+        copy._weights = self._weights
         copy.T = self.T
         copy.base_date = self.base_date
 
-        for sc in self.curves:
+        for sc in self._curves:
             copy_sc = sc.get()
-            copy.curves.push_back(make_shared(JpmcdsCopyCurve(copy_sc)))
+            copy._curves.push_back(make_shared(JpmcdsCopyCurve(copy_sc)))
             temp = <double*>malloc(copy_sc.fNumItems * sizeof(double))
             if temp != NULL:
                 memcpy(<void*>temp, self.recovery_rates[i].get(),
@@ -203,29 +204,30 @@ cdef class CurveList:
     def __reduce__(self):
         return (self.__class__, (self.curves, self.weights))
 
+@cython.auto_pickle(False)
 cdef class CreditIndex(CurveList):
     def __init__(self, start_date, maturities, list curves, double[:] weights=None):
         CurveList.__init__(self, curves, weights)
         self.start_date = pydate_to_TDate(start_date)
         for d in maturities:
-            self.maturities.push_back(pydate_to_TDate(d))
+            self._maturities.push_back(pydate_to_TDate(d))
 
-        self.contingent_legs = <TContingentLeg**> malloc(self.maturities.size() *
+        self.contingent_legs = <TContingentLeg**> malloc(self._maturities.size() *
                                                          sizeof(TContingentLeg))
-        self.fee_legs = <TFeeLeg**> malloc(self.maturities.size() *
+        self.fee_legs = <TFeeLeg**> malloc(self._maturities.size() *
                                            sizeof(TFeeLeg))
         cdef TStubMethod stub_type
         if JpmcdsStringToStubMethod(b"f/s", &stub_type) != 0:
             raise ValueError("can't convert stub")
         cdef size_t i
-        for i in range(self.maturities.size()):
+        for i in range(self._maturities.size()):
             self.contingent_legs[i] = JpmcdsCdsContingentLegMake(self.start_date,
-                                                                 self.maturities[i],
+                                                                 self._maturities[i],
                                                                  1.,
                                                                  True)
 
             self.fee_legs[i] = JpmcdsCdsFeeLegMake(self.start_date,
-                                                   self.maturities[i],
+                                                   self._maturities[i],
                                                    True,
                                                    NULL,
                                                    &stub_type,
@@ -238,10 +240,10 @@ cdef class CreditIndex(CurveList):
 
     def __dealloc__(self):
         if self.contingent_legs is not NULL:
-            for i in range(self.maturities.size()):
+            for i in range(self._maturities.size()):
                 free(self.contingent_legs[i])
         if self.fee_legs is not NULL:
-            for i in range(self.maturities.size()):
+            for i in range(self._maturities.size()):
                 JpmcdsFeeLegFree(self.fee_legs[i])
 
     def __deepcopy__(self, memo):
@@ -251,14 +253,14 @@ cdef class CreditIndex(CurveList):
             size_t i = 0
             TCurve* copy_sc
             CreditIndex copy = CreditIndex.__new__(CreditIndex)
-        copy.weights = self.weights
+        copy._weights = self._weights
         copy.T = self.T
         copy.base_date = self.base_date
         copy.start_date = self.start_date
-        copy.maturities = self.maturities
-        for sc in self.curves:
+        copy._maturities = self._maturities
+        for sc in self._curves:
             copy_sc = sc.get()
-            copy.curves.push_back(make_shared(JpmcdsCopyCurve(copy_sc)))
+            copy._curves.push_back(make_shared(JpmcdsCopyCurve(copy_sc)))
             temp = <double*>malloc(copy_sc.fNumItems * sizeof(double))
             if temp != NULL:
                 memcpy(<void*>temp, self.recovery_rates[i].get(),
@@ -266,9 +268,9 @@ cdef class CreditIndex(CurveList):
             copy.recovery_rates.push_back(shared_ptr[double](temp, double_free))
 
         copy.tickers = self.tickers
-        copy.contingent_legs = <TContingentLeg**>malloc(sizeof(TContingentLeg*) * self.maturities.size())
-        copy.fee_legs = <TFeeLeg**>malloc(sizeof(TFeeLeg*) * self.maturities.size())
-        for i in range(self.maturities.size()):
+        copy.contingent_legs = <TContingentLeg**>malloc(sizeof(TContingentLeg*) * self._maturities.size())
+        copy.fee_legs = <TFeeLeg**>malloc(sizeof(TFeeLeg*) * self._maturities.size())
+        for i in range(self._maturities.size()):
             copy.fee_legs[i] = copyFeeLeg(self.fee_legs[i])
             copy.contingent_legs[i] = copyContingentLeg(self.contingent_legs[i])
         return copy
@@ -282,7 +284,7 @@ cdef class CreditIndex(CurveList):
         cdef:
             TDate step_in_date_c = pydate_to_TDate(step_in_date)
             TDate value_date_c =  pydate_to_TDate(value_date)
-            np.npy_intp[2] n = [self.curves.size(), self.maturities.size()]
+            np.npy_intp[2] n = [self._curves.size(), self._maturities.size()]
             size_t i = 0, j = 0
             np.ndarray[np.float64_t,ndim=2] cl_pv = np.PyArray_EMPTY(2, n, np.NPY_DOUBLE, 0)
             np.ndarray[np.float64_t,ndim=2] fl_pv = np.PyArray_EMPTY(2, n, np.NPY_DOUBLE, 0)
@@ -292,15 +294,15 @@ cdef class CreditIndex(CurveList):
             TCurve* sc
             pair[string, size_t] p
 
-        for maturity in self.maturities:
+        for maturity in self._maturities:
             d[j] = maturity - 134774
             j += 1
         j = 0
 
         for p in self.tickers:
-            sc = self.curves[p.second].get()
+            sc = self._curves[p.second].get()
             tickers.append(p.first.decode())
-            for j in range(self.maturities.size()):
+            for j in range(self._maturities.size()):
                 JpmcdsContingentLegPV(self.contingent_legs[j],
                                       sc.fBaseDate,
                                       value_date_c,
@@ -345,17 +347,17 @@ cdef class CreditIndex(CurveList):
                                                          self.start_date,
                                                          self.contingent_legs,
                                                          self.fee_legs,
-                                                         self.maturities)
+                                                         self._maturities)
 
         if epsilon != 0.:
-            mask = fill_mask(maturity_c, self.maturities, self.curves[0])
+            mask = fill_mask(maturity_c, self._maturities, self._curves[0])
             if mask == 0:
                 raise ValueError("maturity is not correct")
             h = vector[double](self.T.size())
 
-        r = pv(self.curves, self.base_date, step_in_date_c, value_date_c,
+        r = pv(self._curves, self.base_date, step_in_date_c, value_date_c,
                yc._thisptr.get(), legs, recovery_rate, fixed_rate,
-               self.weights, epsilon, h, self.T, mask)
+               self._weights, epsilon, h, self.T, mask)
 
         return r
 
@@ -374,10 +376,10 @@ cdef class CreditIndex(CurveList):
                             self.start_date,
                             self.contingent_legs,
                             self.fee_legs,
-                            self.maturities)
-            old_pv = pv(self.curves, self.base_date, step_in_date_c,
+                            self._maturities)
+            old_pv = pv(self._curves, self.base_date, step_in_date_c,
                         value_date_c, yc._thisptr.get(), legs,
-                        recovery_rate, fixed_rate, self.weights,
+                        recovery_rate, fixed_rate, self._weights,
                         0., h, self.T, 0)
 
         maturity_c = pydate_to_TDate(maturity)
@@ -387,10 +389,10 @@ cdef class CreditIndex(CurveList):
                         self.start_date,
                         self.contingent_legs,
                         self.fee_legs,
-                        self.maturities)
-        return old_pv - pv(self.curves, self.base_date, step_in_date_c, value_date_c,
+                        self._maturities)
+        return old_pv - pv(self._curves, self.base_date, step_in_date_c, value_date_c,
                   yc._thisptr.get(), legs, recovery_rate, fixed_rate,
-                  self.weights, 0., h, self.T, 0) + fixed_rate
+                  self._weights, 0., h, self.T, 0) + fixed_rate
 
     def duration(self, step_in_date, value_date, maturity, YieldCurve yc not None):
 
@@ -401,8 +403,8 @@ cdef class CreditIndex(CurveList):
             TFeeLeg* fl
             size_t i
 
-        for i in range(self.maturities.size()):
-            if self.maturities[i] == maturity_c:
+        for i in range(self._maturities.size()):
+            if self._maturities[i] == maturity_c:
                 fl = self.fee_legs[i]
                 break
         else:
@@ -413,7 +415,7 @@ cdef class CreditIndex(CurveList):
             shared_ptr[TCurve] sc
 
         i = 0
-        for sc in self.curves:
+        for sc in self._curves:
             JpmcdsFeeLegPV(fl,
                            self.base_date,
                            step_in_date_c,
@@ -422,7 +424,7 @@ cdef class CreditIndex(CurveList):
                            sc.get(),
                            True,
                            &fl_pv)
-            r += self.weights[i] * fl_pv
+            r += self._weights[i] * fl_pv
             i += 1
         return r
 
@@ -432,18 +434,18 @@ cdef class CreditIndex(CurveList):
             list r = []
             TDate maturity
 
-        for maturity in self.maturities:
+        for maturity in self._maturities:
             r.append(TDate_to_pydate(maturity))
         return r
 
     def tweak_portfolio(self, double epsilon, maturity, bint inplace=True):
         cdef:
             TDate maturity_c = pydate_to_TDate(maturity)
-            unsigned long mask = fill_mask(maturity_c, self.maturities, self.curves[0])
+            unsigned long mask = fill_mask(maturity_c, self._maturities, self._curves[0])
             vector[double] h = vector[double](self.T.size())
             shared_ptr[TCurve] sc
 
-        for sc in self.curves:
+        for sc in self._curves:
             tweak_curve(sc.get(), sc.get(), epsilon, h, self.T, mask)
 
     def survival_matrix(self, TDate[:] schedule, d1=None):
@@ -451,10 +453,10 @@ cdef class CreditIndex(CurveList):
             shared_ptr[TCurve] sc
             TDate start_date
             size_t i, j
-            np.npy_intp[2] n = [self.curves.size(), schedule.shape[0]]
+            np.npy_intp[2] n = [self._curves.size(), schedule.shape[0]]
             np.ndarray[np.float64_t,ndim=2] sp = np.PyArray_EMPTY(2, n, np.NPY_DOUBLE, 1)
         j = 0
-        for sc in self.curves:
+        for sc in self._curves:
             start_date = sc.get().fBaseDate
             for i in range(n[1]):
                 sp[j,i] = JpmcdsForwardZeroPrice(sc.get(), start_date, schedule[i])