expose new compare function for two result

Author: yellowbean

absbox/client.py

@@ -8,11 +8,11 @@
 from requests.exceptions import ConnectionError, ReadTimeout
 import pandas as pd
 from rich.console import Console
+from rich import print_json
 from schema import Schema
 import toolz as tz
 from lenses import lens
 
-
 from absbox.validation import isValidUrl, vStr
 from absbox.local.util import mkTag,mapValsBy \
                               , _read_cf, _read_asset_pricing, mergeStrWithDict \
@@ -103,8 +103,9 @@ class LibraryEndpoints(str, enum.Enum):
     Ack = "ack"
     Token = "token"
     Query = "query"
-    Run = "run"
-    DealAdd = "deal/add"
+    Run = "run" # run a deal from the library
+    Add = "add" # add new deal to library
+    Get = "get" # get deal from library
     # Data = "data"
     # DataList = "data/list"
     # DealFetch = "deal/fetch"
@@ -888,7 +889,9 @@ def __post_init__(self):
             self.session = requests.Session()
             self.libraryInfo = json.loads(_r.text)
             console.print(f"✅ Connected to library server")
-            console.print(f"✅ absbox version:{self.libraryInfo['absbox']}, Hastructure:{self.libraryInfo['Hastructure']}")
+            #print_json(data=self.libraryInfo['Hastructure'])
+            console.print(f"absbox version:{self.libraryInfo['absbox']}")
+            console.print(f"Hastructure:{self.libraryInfo['Hastructure']}")
         else:
             console.print(f"❌ Failed to connect to library server")
 
@@ -910,10 +913,8 @@ def login(self, user, pw, **q):
         cred = {"user": vStr(user), "password": pw}
         r = self._send_req(json.dumps(cred), deal_library_url)
         if 'token' in r:
-            console.print(f"✅ login successfully, user-> {r['user']},company-> {r['group']}")
-            #console.print("✅ token is updated",r['token'])
+            console.print(f"✅ login successfully, user -> {r['user']},group -> {r['group']}")
             self.token = r['token']
-            #self._send_req(json.dumps({"token": self.token}), deal_library_url)
         else:
             if hasattr(self, 'token'):
                 delattr(self, 'token')
@@ -968,7 +969,7 @@ def query(self, k = {}, read=True):
         else:
             return result
 
-    def dealAdd(self, d, **p):
+    def add(self, d, **p):
         """add deal to library"""
 
         if not hasattr(self, "token"):
@@ -979,9 +980,8 @@ def dealAdd(self, d, **p):
             "deal":d
             ,"name": d.name
             ,"json": d.json
-            ,"extra": p.get("extra",{})
             ,"period": p.get("period",0)
-            ,"buildVersion": absbox.__version__
+            ,"buildVersion": "0.43.1"
             ,"stage": p.get("stage","")
             ,"comment": p.get("comment","")
             ,"permission": p.get("permission","700")
@@ -993,9 +993,22 @@ def dealAdd(self, d, **p):
         r = self._send_req(bData, deal_library_url
                             , headers={"Authorization": f"Bearer {self.token}"
                                         ,"Content-Type":"application/octet-stream"})
+        
+
 
-        console.print(f"✅ add success")
+        console.print(f"✅ add success with deal id={r['dealId']}, name={r['name']}")
 
+    def dealGet(self, q):
+        if not hasattr(self, "token"):
+            raise AbsboxError(f"❌ No token found, please call login() to login")
+        deal_library_url = self.url+f"/{LibraryEndpoints.DealGet.value}"
+
+        r = self._send_req(pickle.dumps({"q":q}), deal_library_url
+                            , headers={"Authorization": f"Bearer {self.token}"
+                                        ,"Content-Type":"application/octet-stream"})
+        
+        return r
+        console.print(f"✅ get deal success")
 
     def run(self, _id, **p):
         """send deal id with assumptions to remote server and get result back
@@ -1021,8 +1034,8 @@ def run(self, _id, **p):
         runType = p.get("runType", "S")
 
         runReq = {"q": _id, "runType": runType 
-                    ,"runAssump": runAssump, "poolAssump": poolAssump
-                    ,"engine": p.get("engine",None) }
+                ,"runAssump": runAssump, "poolAssump": poolAssump
+                ,"engine": p.get("engine",None) }
 
         bRunReq = pickle.dumps(runReq)
 
@@ -1032,16 +1045,17 @@ def run(self, _id, **p):
 
         try:
             result = r['result']
+            runInfo = tz.dissoc(r, 'result')
             console.print(f"✅ run success with deal")
         except Exception as e:
             raise AbsboxError(f"❌ message from API server:{result},\n,{e}")
         try:       
             if read and isinstance(result, list):
-                return Generic.read(result)
+                return (runInfo, Generic.read(result))
             elif read and isinstance(result, dict):
-                return tz.valmap(Generic.read, result)
+                return (runInfo, tz.valmap(Generic.read, result))
             else:
-                return result
+                return (runInfo, result)
         except Exception as e:
             raise AbsboxError(f"❌ Failed to read result with error = {e}")
 

absbox/local/base.py

@@ -111,17 +111,11 @@
 boolLikeFormula = set(["trigger", "事件", "isMostSenior", "最优先", "isPaidOff","清偿完毕","rateTest","allTest","anyTest","比率测试","任一测试","所有测试"
                         "isOutstanding"])
 
-bookDirection = {"Credit":"Credit"
-                ,"Debit":"Debit"
-                ,"借方":"Debit"
-                ,"贷方":"Credit"
-                ,"D":"Debit"
-                ,"C":"Credit"
-                ,"DR":"Debit"
-                ,"CR":"Credit"
-                ,"Dr":"Debit"
-                ,"Cr":"Credit"
-                }
+bookDirection = {"Credit":"Credit" ,"Debit":"Debit"
+                ,"借方":"Debit" ,"贷方":"Credit"
+                ,"D":"Debit" ,"C":"Credit"
+                ,"DR":"Debit" ,"CR":"Credit"
+                ,"Dr":"Debit" ,"Cr":"Credit"}
 
 
 op_map = {">": "G", ">=": "GE", "<": "L", "<=": "LE", "=": "E"}

absbox/local/cmp.py

@@ -1,44 +1,83 @@
 import pandas as pd
 
 
-def comp_df(x, y):
-    return pd.merge(x, y, on="日期", how='outer').sort_index().sort_index(axis=1)
 
-def comp_engines(engine1, engine2, d, pA=None,rA=[], a=None):
-    
-    r1 = engine1.run(d, poolAssump=pA, runAssump=rA, read=True)
-    r2 = engine2.run(d, poolAssump=pA, runAssump=rA, read=True)
+def compResult(r1:dict, r2:dict, names=("Left", "Right")):
+    """ compare first to second result
+
+    :param r1: run result 1
+    :type r1: dict
+    :param r2: run result 2 ( to be compared with r1)
+    :type r2: dict
+    :param names: name of the results, defaults to ("Left", "Right")
+    :type names: tuple, optional
+    """
 
+    def compDf(x, y):
+        (nameA,nameB) = names
+        x, y = x.align(y, fill_value=pd.NA)
+        cmp = x.compare(y, result_names=(nameA,nameB))
+        result = cmp.copy()
+        for column in cmp.columns.levels[0]:
+            if pd.api.types.is_numeric_dtype(cmp[column][nameA]) and pd.api.types.is_numeric_dtype(cmp[column][nameB]):
+                result[column, 'diff'] = cmp[column][nameA].fillna(0) - cmp[column][nameB].fillna(0)
+        #return result.sort_index(axis=1,level=1)
+        return result.reindex(axis=1, level=1, labels=[nameA, nameB, 'diff'])
+
+    # r1 -> Left
+    # r2 -> Right
     comp_result = {}
     # pool check
-    if not r1['pool']['flow'].equals(r2['pool']['flow']):
-        comp_result['pool'] = comp_df(r1['pool']['flow'], r2['pool']['flow'])
-    else:
-        comp_result['pool'] = True
+    comp_result['pool'] = {}
+    for k,v in r1['pool']['flow'].items():
+        if not v.equals(r2['pool']['flow'][k]):
+            comp_result['pool'][k] = compDf(v, r2['pool']['flow'][k])
+        else:
+            comp_result['pool'] = True
 
     # expense check  
     comp_result['fee'] = {}
     for fn, f in r1['fees'].items():
         if not f.equals(r2['fees'][fn]):
-            comp_result['fee'][fn] = comp_df(f, r2['fees'][fn])
+            comp_result['fee'][fn] = compDf(f, r2['fees'][fn])
         else:
             comp_result['fee'][fn] = True
 
     # bond check
     comp_result['bond'] = {}
     for fn, f in r1['bonds'].items():
         if not f.equals(r2['bonds'][fn]):
-            comp_result['bond'][fn] = comp_df(f, r2['bonds'][fn])
+            comp_result['bond'][fn] = compDf(f, r2['bonds'][fn])
         else:
             comp_result['bond'][fn] = True
 
-
     # account check
     comp_result['account'] = {}
     for fn, f in r1['accounts'].items():
         if not f.equals(r2['accounts'][fn]):
-            comp_result['account'][fn] = comp_df(f, r2['accounts'][fn])
+            comp_result['account'][fn] = compDf(f, r2['accounts'][fn])
         else:
             comp_result['account'][fn] = True
 
+    # ledger check 
+    comp_result['ledger'] = {}
+    if 'ledgers' in r1:
+        for fn, f in r1['ledgers'].items():
+            if not f.equals(r2['ledgers'][fn]):
+                comp_result['ledger'][fn] = compDf(f, r2['ledgers'][fn])
+            else:
+                comp_result['ledger'][fn] = True
+    
+    comp_result['trigger'] = {}
+    if 'triggers' in r1:
+        for locName, tMap in r1['triggers'].items() :
+            if len(tMap) == 0:
+                continue
+            comp_result['trigger'][locName] = {}
+            for tn, t in tMap.items():
+                if not t.equals(r2['triggers'][locName][tn]):
+                    comp_result['trigger'][locName][tn] = compDf(t, r2['triggers'][locName][tn])
+                else:
+                    comp_result['trigger'][locName][tn] = True
+    
     return comp_result

docs/source/analytics.rst

@@ -2150,3 +2150,34 @@ Built-in Comparision functions
 .. seealso::
   There are couple built-in functions will help user to get result in easier way :ref:`Read Multiple Result Map`
 
+
+
+Compare two results
+""""""""""""""""""""""""
+
+.. versionadded:: 0.43.1
+
+User can compare two results with a built-in function ``compResult`` , it will return a dict with difference of two results.
+
+User can inspect difference as below:
+
+.. code-block:: python
+
+  from absbox import API,EnginePath,compResult
+
+  r1 = localAPI.run(<Deal1>
+                  ,poolAssump = ("Pool",("Mortgage",{"CDR":0.12},None,None,None)
+                                        ,None
+                                        ,None)
+                  ,read=True)
+
+
+  r2 = localAPI.run(<Deal1>
+                  ,poolAssump = ("Pool",("Mortgage",{"CDR":0.11},None,None,None)
+                                        ,None
+                                        ,None)
+                  ,read=True)
+
+  diff = compResult(r1,r2,names=("highCDR","lowCDR"))
+
+  diff['bond']['senior'][['balance','cash']]

docs/source/modeling.rst

@@ -2124,6 +2124,8 @@ The bond interest will be calculated by a base from a :ref:`Formula`
 It use a composite syntax: ``("byRefBalance",<formula>,<rate object>)``
 
 syntax
+  :code:`"rateType":("refBalance",("*",("bondBalance","A","B"), 0.3) ,{"Fixed":0.06})`
+  
   :code:`"rateType":("byRefBalance",("poolBalance",),("fix",0.0569))`