modelswrkpi 8.1.3__py3-none-any.whl → 9.0.1__py3-none-any.whl

models/bro_clicks/load_balancer/__init__.py

@@ -4,3 +4,4 @@ from models.bro_clicks.load_balancer.v3 import LoadBalancerV3
 from models.bro_clicks.load_balancer.v4 import LoadBalancerV4
 from models.bro_clicks.load_balancer.v5 import LoadBalancerV5
 from models.bro_clicks.load_balancer.v6 import LoadBalancerV6
+from models.bro_clicks.load_balancer.v7 import LoadBalancerV7

models/bro_clicks/load_balancer/compile.py

@@ -8,6 +8,7 @@ ext_modules = [
     Extension("v4",  ["v4.py"], extra_compile_args=["-g0"]),
     Extension("v5",  ["v5.py"], extra_compile_args=["-g0"]),
     Extension("v6",  ["v6.py"], extra_compile_args=["-g0"]),
+    Extension("v7",  ["v7.py"], extra_compile_args=["-g0"]),
 ]
 setup(
     name='load_balancer',

models/bro_clicks/load_balancer/v1.py

@@ -12,6 +12,7 @@ class LoadBalancer(Db):
         self.set_constraint('load_balancer_2_pk', ['date', 'crm_id', 'gateway_id', 'router_id'])
         self.db_p = db_p
         self._account_id = account_id
+        self.is_cc_type_cap_split = False
 
     @staticmethod
     def set_max_decline_attempts(attempts):
@@ -44,7 +45,9 @@ class LoadBalancer(Db):
 
     def get_processing_for_month(self, crm_id):
         qry = f"""
-                select b.gateway_id, count(a.order_id)::int  initial_count_mtd from  augmented_data.order_cycles a 
+                select b.gateway_id, 
+                count(a.order_id)::int  initial_count_mtd 
+                from  augmented_data.order_cycles a 
                 inner join crm_global.orders  b on  a.order_id  = b.order_id and a.crm_id  =  b.crm_id   and a.crm_id = '{crm_id}'
                 where a.time_stamp  > '{self.get_first_om()}' and a.time_stamp < '{self.today()}'::timestamp
                       and a.bc_inferred  = 0
@@ -56,16 +59,52 @@ class LoadBalancer(Db):
         # print(qry)
         return pd.read_sql(qry, self.db_p.engine).fillna(0)
 
+    def get_processing_for_month_cc_type(self, crm_id):
+        qry = f"""
+                select
+                gateway_id, 
+                (initial_count_mtd - visa_count_mtd)::int as initial_count_mtd,
+                visa_count_mtd
+                from
+                (select b.gateway_id, 
+                        count(a.order_id)::int initial_count_mtd, 
+                        (count(a.order_id) filter(where lower(cc_type) = 'visa'))::int visa_count_mtd 
+                        from  augmented_data.order_cycles a 
+                inner join crm_global.orders  b on  a.order_id  = b.order_id and a.crm_id  =  b.crm_id   and a.crm_id = '{crm_id}'
+                where a.time_stamp  > '{self.get_first_om()}' and a.time_stamp < '{self.today()}'::timestamp
+                      and a.bc_inferred  = 0
+                      and a.decline_reason is null
+                      and b.is_test_cc::int <> '1'                                            
+                group by b.gateway_id) a
+        """
+
+        # print(qry)
+        return pd.read_sql(qry, self.db_p.engine).fillna(0)
+
     def init_date(self, date, crm_id, reset_cap_count=True):
         sk = f'ui_{self._account_id}_clients'
         real_cap_space = self.get_processing_for_month(crm_id) if reset_cap_count else None
 
         qry = f"""
                 SELECT '{date}'::date as date,  b.crm_id, a.mid_id,   b.gateway_id, b.step, a.processor,                  
-                                                coalesce(e.approved, 0)  approved,  coalesce(e.approved,0) initial_count, c.dly_initial_cap,  b.minimum_price, coalesce(e.declined, 0) declined, 
-                                                d.approval_rate,  c.dly_min_approval_rate, array_to_string(c.pr_exclude_cc_types,  ',') exclude_cc_types , 
-                                                c.date_added, c.enable_tds, array_to_string(c.tds_exclude_cc_types, ',') tds_exclude_cc_types,  c.enabled, c.enable_initials, c.monthly_initial_cap, c.priority, c.router_id,  d.router_id as cur_router_id,                                                
-                                                d.soft_cap_alerted, d.initial_count_mtd  as  prev_mtd                      
+                                                coalesce(e.approved, 0)  approved,  
+                                                coalesce(e.approved,0) initial_count, 
+                                                c.dly_initial_cap,  b.minimum_price, 
+                                                coalesce(e.declined, 0) declined, 
+                                                d.approval_rate,  
+                                                c.dly_min_approval_rate, 
+                                                array_to_string(c.pr_exclude_cc_types,  ',') exclude_cc_types , 
+                                                c.date_added, 
+                                                c.enable_tds, 
+                                                array_to_string(c.tds_exclude_cc_types, ',') tds_exclude_cc_types, 
+                                                c.enabled, 
+                                                c.enable_initials, 
+                                                c.monthly_initial_cap, 
+                                                c.priority, 
+                                                c.router_id,  
+                                                d.router_id as cur_router_id,                                                
+                                                d.soft_cap_alerted, 
+                                                d.initial_count_mtd  as  prev_mtd                      
 
                 FROM {sk}.mids a 
                 LEFT JOIN {sk}.steps b on b.mid_id = a.mid_id 
@@ -135,18 +174,25 @@ class LoadBalancer(Db):
         # self.engine.execute(f'truncate {self.schema}.{self.table}')
         self.upsert(up.dropna())
 
-    def _increment_conversion(self, date, gateway_id, crm_id, approved, recurs_attempt=0, **kwargs):
-        inc_p = '(initial_count +1)'
-        m_inc_p = '(initial_count_mtd +1)'
-        dnc_p = '(declined + 1)'
-        inc = 'initial_count'
-        m_inc = 'initial_count_mtd'
+    def _increment_conversion(self, date, gateway_id, crm_id, approved, recurs_attempt=0, cc_type=None, **kwargs):
+        if cc_type.lower() == 'visa':
+            inc_p = '(visa_count +1)'
+            m_inc_p = '(visa_count_mtd +1)'
+            inc = 'visa_count'
+            m_inc = 'visa_count_mtd'
+
+        else:
+            inc_p = '(initial_count +1)'
+            m_inc_p = '(initial_count_mtd +1)'
+            inc = 'initial_count'
+            m_inc = 'initial_count_mtd'
         dnc = 'declined'
+        dnc_p = '(declined + 1)'
         try:
             qry = f"""
                 UPDATE {self.schema}.{self.table} 
-                set   {f"{inc} ={inc_p},  approval_rate = ({inc_p}::numeric / ({dnc}+{inc_p}::numeric))*100, {m_inc} = {m_inc_p}" if approved
-            else f"{dnc} ={dnc_p}, approval_rate = case when {inc}>0 then ({inc} / ({dnc_p}+{inc}))*100 else 0 end "
+                set   {f"{inc} ={inc_p},  approval_rate = ((initial_count+visa_count+1)::numeric / ({dnc}+(initial_count+visa_count+1)::numeric))*100, {m_inc} = {m_inc_p}" if approved
+        else f"{dnc} ={dnc_p}, approval_rate = case when visa_count+initial_count>0 then ((visa_count+initial_count)::numeric / ({dnc_p}+visa_count+initial_count)::numeric * 100) else 0 end "
             }
                 where crm_id = '{crm_id}' and date = '{date}'::date and gateway_id='{gateway_id}'                
                 returning gateway_id  
@@ -165,9 +211,11 @@ class LoadBalancer(Db):
     def increment_conversion(self, date, gateway_id, crm_id, approved, **kwargs):
         return self._increment_conversion(date, gateway_id, crm_id, approved, recurs_attempt=0, **kwargs)
 
-    def set_soft_cap_alerted(self, crm_id):
+    def set_soft_cap_alerted(self, crm_id, cc_type=None, **kw):
         self.engine.execute(
-            f"""Update {self.schema}.{self.table} set  soft_cap_alerted=true where crm_id= '{crm_id}'""")
+            f"""Update {self.schema}.{self.table} 
+            {"set visa_soft_cap_alerted=true" if cc_type.lower()=='visa' else "set  soft_cap_alerted=true"}
+             where crm_id= '{crm_id}'""")
 
     def disable(self, crm_id, gateway_id):
         self.engine.execute(

models/bro_clicks/load_balancer/v5.py

@@ -15,12 +15,28 @@ class LoadBalancerV5(LoadBalancerV4):
         real_cap_space = self.get_processing_for_month(crm_id) if reset_cap_count else None
 
         qry = f"""
-                SELECT '{date}'::date as date,  b.crm_id, a.mid_id,   b.gateway_id, b.step, a.processor,                  
-                                                coalesce(e.approved, 0)  approved,  coalesce(e.approved,0) initial_count, c.dly_initial_cap,  b.minimum_price, coalesce(e.declined, 0) declined, 
-                                                d.approval_rate,  c.dly_min_approval_rate, array_to_string(c.pr_exclude_cc_types,  ',') exclude_cc_types , 
-                                                c.date_added, c.enable_tds, array_to_string(c.tds_exclude_cc_types, ',') tds_exclude_cc_types,  c.enabled, c.enable_initials, c.monthly_initial_cap, c.priority, c.router_id,  d.router_id as cur_router_id,                                                
-                                                c.allow_prepaid, c.allow_non_prepaid,
-                                                d.soft_cap_alerted, d.initial_count_mtd  as  prev_mtd                      
+                SELECT '{date}'::date as date,  b.crm_id,  a.mid_id,   b.gateway_id, b.step, a.processor,                  
+                        coalesce(e.approved, 0)  approved,  
+                        coalesce(e.approved,0) initial_count, 
+                        c.dly_initial_cap,  
+                        b.minimum_price, 
+                        coalesce(e.declined, 0) declined, 
+                        d.approval_rate,  
+                        c.dly_min_approval_rate, 
+                        array_to_string(c.pr_exclude_cc_types,  ',') exclude_cc_types , 
+                        c.date_added, 
+                        c.enable_tds, 
+                        array_to_string(c.tds_exclude_cc_types, ',') tds_exclude_cc_types,  
+                        c.enabled, 
+                        c.enable_initials, 
+                        c.monthly_initial_cap, 
+                        c.priority, 
+                        c.router_id,  
+                        d.router_id as cur_router_id,                                                
+                        c.allow_prepaid, 
+                        c.allow_non_prepaid,
+                        d.soft_cap_alerted, 
+                        d.initial_count_mtd  as  prev_mtd                      
 
                 FROM {sk}.mids a 
                 LEFT JOIN {sk}.steps b on b.mid_id = a.mid_id 

models/bro_clicks/load_balancer/v6.py

@@ -40,9 +40,6 @@ class LoadBalancerV6(LoadBalancerV5):
         with ThreadPoolExecutor(max_workers=1) as executor:
             self._t_get_bin = executor.submit(_exec)  # Task that takes 5 seconds
 
-          
-        
-
     def next_gateway(self, crm_id, date, step, click_id='', processor=False, cc_type=None, cc_first_8=False, recurse=0,
                      decs=False, ignore_user_exclusions=None,
                      proc_excl=[], is_tds=None, is_prepaid=True, **kwargs):

models/bro_clicks/load_balancer/v7.py

@@ -1,8 +1,310 @@
-import random
-from models.db import Db, pd
-from models.bro_clicks.initial_routes import InitialRoutes, ForeignInitialRoutes
-from calendar import monthrange
-import datetime as dt
-from models import config
-from threading import Thread, Lock
-from copy import deepcopy
+from models.bro_clicks.load_balancer.v6 import LoadBalancerV6
+import pandas as pd
+from numpy import nan as np_nan
+
+
+class LoadBalancerV7(LoadBalancerV6):
+
+    def __init__(self, *args, **kw):
+        LoadBalancerV6.__init__(self, *args, **kw)
+        self.version = 7
+        self.is_cc_type_cap_split = True
+
+    def init_date(self, date, crm_id, reset_cap_count=True):
+        sk = f'ui_{self._account_id}_clients'
+        real_cap_space = self.get_processing_for_month_cc_type(crm_id) if reset_cap_count else None
+
+        qry = f"""
+                  SELECT '{date}'::date as date,  b.crm_id, a.mid_id,   b.gateway_id, b.step, a.processor,                  
+                                                  coalesce(e.approved, 0)  approved,  
+                                                  coalesce(e.o_approved,0) initial_count,
+                                                  coalesce(e.v_approved,0) visa_count,  
+                                                  c.dly_initial_cap,  
+                                                  c.visa_dly_cap,
+                                                  b.minimum_price, 
+                                                  coalesce(e.declined, 0) declined, 
+                                                  d.approval_rate,  
+                                                  c.dly_min_approval_rate, 
+                                                  array_to_string(c.pr_exclude_cc_types,  ',') exclude_cc_types , 
+                                                  c.date_added, 
+                                                  c.enable_tds, 
+                                                  array_to_string(c.tds_exclude_cc_types, ',') tds_exclude_cc_types, 
+                                                  c.enabled, 
+                                                  c.enable_initials, 
+                                                  c.monthly_initial_cap, 
+                                                  c.visa_monthly_cap,
+                                                  c.priority, 
+                                                  c.router_id,  
+                                                  d.router_id as cur_router_id,                                                
+                                                  d.soft_cap_alerted,
+                                                   d.visa_soft_cap_alerted,  
+                                                  d.initial_count_mtd  as  prev_mtd,
+                                                  d.visa_count_mtd  as  prev_visa_mtd                        
+
+                  FROM {sk}.mids a 
+                  LEFT JOIN {sk}.steps b on b.mid_id = a.mid_id 
+                  LEFT JOIN {sk}.gateway_settings c on c.gateway_id = b.gateway_id and c.crm_id = b.crm_id
+                  LEFT JOIN {self.schema}.{self.table} d on c.gateway_id =d.gateway_id and c.crm_id = d.crm_id and  b.step = d.step and '{date}'::date =d.date
+                  LEFT JOIN (select  crm_id, gateway_id, 
+                  coalesce(sum(declined),  0) declined,   
+                  coalesce(sum(approved), 0) approved,
+                  coalesce(sum(approved) filter (where lower(cc_type)='visa'), 0) v_approved,
+                  coalesce(sum(approved) filter (where lower(cc_type)<>'visa'), 0) o_approved   
+                              from {self.schema}.conversions where  coalesce(test, 0) <>  1 and time_stamp::date =  '{date}'::date group by crm_id, gateway_id
+                              ) e on  e.gateway_id =c.gateway_id and e.crm_id=c.crm_id
+                  where (b.close_date is  null or b.close_date >'{self.today()}')
+                      and b.crm_id = '{crm_id}' 
+                      and b.gateway_id is not null
+                      and a.processor not ilike '%%virtual%%'
+                      and b.gateway_id::int <> 1
+                      and a.processor != 'FlexCharge'                    
+
+              """
+
+        try:
+            up = pd.read_sql(qry, self.engine)
+            up = up.sort_values('step').drop_duplicates(['gateway_id', 'cur_router_id'], keep='first')
+            up = up.loc[~up.router_id.isna()]
+            up = up.explode('router_id')
+
+            # delete  changes to routers
+            del_gt_msk = (up.router_id != up.cur_router_id) & (
+                up.gateway_id.isin(up.loc[~up.cur_router_id.isna()].gateway_id.unique()))
+            del_gtys = up.loc[del_gt_msk].gateway_id.tolist()
+            up = up.loc[(~up.gateway_id.isin(del_gtys)) | (~up.cur_router_id.isna())]
+
+            # delete  changes to routers
+            del_gt_msk = (up.router_id != up.cur_router_id)
+            del_gtys = up.loc[del_gt_msk].gateway_id.tolist()
+            self.engine.execute(
+                f"delete from {self.schema}.{self.table} where gateway_id::int = ANY(ARRAY{del_gtys}::int[]) and  crm_id='{crm_id}'")
+            up = up.drop(columns='cur_router_id')
+        except Exception as e:
+            raise e
+        if reset_cap_count:
+            try:
+                up = up.merge(real_cap_space[['gateway_id', 'initial_count_mtd']], on=['gateway_id'], how='left')
+                up.initial_count_mtd = up.initial_count_mtd.fillna(0)
+                up.initial_count_mtd += up.initial_count
+
+            except:
+                up['initial_count_mtd'] = up.prev_mtd.fillna(0)
+                up.initial_count_mtd = up.initial_count_mtd.fillna(0)
+
+            try:
+                up = up.merge(real_cap_space[['gateway_id', 'visa_count_mtd']], on=['gateway_id'], how='left')
+                up.visa_count_mtd = up.visa_count_mtd.fillna(0)
+                up.visa_count_mtd += up.visa_count
+
+            except:
+                up['visa_count_mtd'] = up.prev_visa_mtd.fillna(0)
+                up.initial_count_mtd = up.initial_count_mtd.fillna(0)
+
+            drim = float(self.get_drim())
+            up.dly_initial_cap = pd.np.floor((up.monthly_initial_cap - up.initial_count_mtd) / drim)
+            up.visa_dly_cap = pd.np.floor((up.visa_monthly_cap - up.visa_count_mtd) / drim)
+            up.loc[up.dly_initial_cap < 0, 'dly_initial_cap'] = 0
+            up.loc[up.visa_dly_cap < 0, 'visa_dly_cap'] = 0
+
+        up.dly_initial_cap = up.dly_initial_cap.fillna(11)
+        up.visa_dly_cap = up.visa_dly_cap.fillna(11)
+        up.dly_min_approval_rate = up.dly_min_approval_rate.fillna(30)
+        up.declined = up.declined.fillna(0)
+        up.approval_rate = up.approval_rate.fillna(0)
+        up.soft_cap_alerted = up.soft_cap_alerted.fillna(False)
+        up.visa_soft_cap_alerted = up.visa_soft_cap_alerted.fillna(False)
+        up.drop('prev_mtd', axis=1, errors='ignore', inplace=True)
+        up = up.drop_duplicates(['gateway_id', 'router_id'])
+        # self.engine.execute(f'truncate {self.schema}.{self.table}')
+        self.upsert(up.dropna())
+
+    def gty_qry(self, crm_id, date, step, processor, cc_type=False, decs='', proc_excl=[], is_tds=None,
+                is_prepaid=False, is_decline_salvage=False, **kw):
+        p_ex = ''
+        if proc_excl and len(proc_excl) and not processor:
+            p_ex = f"and a.processor not ilike all(ARRAY{[f'%%{p}%%' for p in proc_excl]}::text[])"
+
+        if str(cc_type).lower() == 'visa':
+            dyna_cap_cols = "a.visa_fill_pct fill_pct, a.visa_dly_cap dly_initial_cap, a.visa_monthly_cap monthly_initial_cap,  a.visa_soft_cap_alerted soft_cap_alerted, a.visa_count_mtd initial_count_mtd, a.visa_count initial_count, a.soft_cap_alerted sca2"
+        else:
+            dyna_cap_cols = "a.fill_pct, a.dly_initial_cap, a.monthly_initial_cap, a.soft_cap_alerted, initial_count_mtd, initial_count, a.visa_soft_cap_alerted sca2"
+
+
+        return f""" --LEFT HERE NEED TO GET MCC!
+                       select a.gateway_id::int,  priority,   a.approval_rate, a.date_added, a.processor, a.mid_id, b.mcc,
+                       {dyna_cap_cols} 
+                       from {self.schema}.{self.table} a
+                       inner join (select crm_id,  gateway_id,  mcc from ui_54407332_clients.steps ) b  on b.crm_id =  a.crm_id and  b.gateway_id=a.gateway_id
+                       {"inner join (select crm_id, gateway_id where enable_decline_salvage) ds on ds.crm_id = a.crm_id and ds.gateway_id::int = a.gateway_id::int" if is_decline_salvage else ""}
+                       inner join processing.cap c on a.mid_id = c.mid_id and a.step=c.step and a.processor=c.processor and c.monthly_available > 200
+                        {f"left join processing.cap_cc_type d on a.mid_id = d.mid_id and a.step= d.step  and a.processor = d.processor and d.cc_type = '{cc_type}' " if cc_type else ''}
+
+                       where date = '{date}'::date and a.crm_id = '{crm_id}' and router_id = '{step if step in [1, 11] else 2}' and enabled and enable_initials
+                                    {f"and a.processor = '{processor}'" if processor else ""}
+                                     {f"and (exclude_cc_types is null or  exclude_cc_types::text  not ilike '%%{cc_type.lower()}%%')" if cc_type else ''}
+                                     and (approval_rate > dly_min_approval_rate or(declined+initial_count<110))
+                                     {'and (d.available_tc is null or d.available_tc >50)' if cc_type else ''}
+                                     {decs}
+                                     {p_ex}
+                                     {f"and enable_tds = {bool(is_tds)}" if is_tds else ""}
+                                     {f"and (tds_exclude_cc_types is null or tds_exclude_cc_types not ilike '%%{cc_type}%%')" if cc_type and is_tds else ""}
+                                     {f"and allow_prepaid" if is_prepaid else ""}
+                                     {f"and allow_non_prepaid" if not is_prepaid else ""}
+                                     --and fill_pct < 1                         
+
+                       --order by date_added desc, approval_rate desc, fill_pct asc limit 1
+                         order by priority desc, date_added  desc, fill_pct, approval_rate desc, initial_count
+
+                   """
+
+    def next_gateway(self, crm_id, date, step, click_id='', processor=False, cc_type=None, cc_first_8=False, recurse=0,
+                     decs=False, ignore_user_exclusions=None,
+                     proc_excl=[], is_tds=None, is_prepaid=True, **kwargs):
+        # opt vals 1 = random gateway constrained only by cap,  2 = optimised gateway constrained only by cap, 3 = Hybrid approach not ignoring settings, 4 = over cap (over-rides to that if needed)
+        if is_prepaid is None:
+            raise TypeError('is_prepaid value must be pass as a boolean got NoneType')
+
+        if is_prepaid:
+            pp_campaign_class = 'prepaid'
+        else:
+            pp_campaign_class = 'post_paid'
+        if ignore_user_exclusions is None:
+            ignore_user_exclusions = self._opt_val < 2
+        if cc_first_8:
+            self.set_bin_info(cc_first_8)
+        try:
+            decs = self.exclude_list(crm_id, step, click_id, 'a.') if not decs else decs
+        except Exception as e:
+            return str(e)
+
+        try:
+            qry = self.gty_qry(crm_id, date, step, processor, cc_type, decs, proc_excl=proc_excl, is_tds=is_tds,
+                               is_prepaid=is_prepaid, **kwargs)
+            res = pd.read_sql(qry, self.engine)
+            cc_type = cc_type.lower()
+            if 'master' in cc_type:
+                cc_type = 'master'
+            try:
+                result = self._t_get_bin.result(timeout=4)  # Wait for 2 seconds
+            except TimeoutError:
+                print("IIN INFO timed out!")
+            except Exception as e:
+                print(f"An error occurred: {e}")
+            if self._opt_val > 1 and self._opt_val < 4 and self.routes is not None:
+
+                self._lock_model_replace.acquire()
+                mod = self.routes if self.is_iin_data else self.routes.loc[
+                    self.routes.mod_type.isin(['cc_type_conversion', 'cc_type_mcc_conversion'])]
+                self._lock_model_replace.release()
+                if len(mod):  # and 'conversion_rate' in mod.columns:
+                    if 'cc_level' not in mod.columns:
+                        mod['cc_level'] = np_nan
+                    if 'mcc' not in mod.columns:
+                        mod['mcc'] = np_nan
+                    mod = mod.loc[(mod.approved + mod.declined >= self._min_sample_count)
+                                  # & (mod.conversion_rate != 1)  # take out dummy gateways
+                                  & ((mod.cc_first_8 == cc_first_8) | (mod.cc_first_8.isna()))
+                                  & (mod.campaign_class == pp_campaign_class)
+                                  & (((mod.cc_type == cc_type) | mod.cc_type.isna()) if 'cc_type' in mod.columns else (
+                        True))
+                                  & (((mod.cc_level == str(self.iin_info['level'])) | (
+                        mod.cc_level.isna())) if self.is_iin_data and 'level' in self.iin_info else (True))
+                                  & (((mod.bank == str(self.iin_info['bank'])) | (
+                        mod.bank.isna())) if self.is_iin_data and 'bank' in self.iin_info else (True))
+                                  ]
+
+                    df_opt = mod.copy().sort_values('conversion_rate', ascending=False).reset_index(drop=True)
+                    df_opt['r_rank'] = df_opt.index + 1
+
+                    # Optimization Filters
+
+                    res = res.merge(df_opt.loc[df_opt.mod_type.isin(
+                        ['cc_type_mcc_conversion', 'bank_conversion'])],
+                                    on=['processor', 'mcc'],
+                                    how='left').append(res.merge(
+                        df_opt.loc[df_opt.mod_type.isin(
+                            ['cc_type_cc_level_conversion', 'cc_type_conversion', 'iin_conversion'])].drop('mcc',
+                                                                                                           axis=1),
+                        on=['processor'],
+                        how='left')).sort_values('r_rank')
+                else:
+                    res['mod_type'] = 'undefined'
+                    res['conversion_rate'] = 0
+                # r_rank is Highest to lowest in terms of strength same as priority
+                res.mod_type = res.mod_type.fillna('undefined').replace({'nan': 'undefined', '': 'undefined'})
+                res.conversion_rate = res.conversion_rate.fillna(0)
+            else:
+                res['conversion_rate'] = 0
+                res['mod_type'] = 'undefined'
+            res = res.sort_values(**self.sort_map[self._opt_val]).drop_duplicates('gateway_id', keep='first')
+            res['cc_type'] = cc_type
+            res['cc_first_8'] = cc_first_8
+            self.set_iin(cc_first_8=cc_first_8, cc_type=cc_type)
+        except Exception as e:
+            print('LBV4 error', str(e))
+            raise e
+
+        if res is None or not len(res):
+            if not decs:
+                if not recurse and is_tds is not None:
+                    return self.next_gateway(crm_id, date, step, click_id, processor, cc_type, recurse=recurse + 1,
+                                             is_tds=not is_tds, is_prepaid=is_prepaid)
+                elif recurse == 1:
+                    self.init_date(date, crm_id)
+                    return self.next_gateway(crm_id, date, step, click_id, processor, cc_type, recurse=recurse + 1,
+                                             is_tds=is_tds, is_prepaid=is_prepaid)
+                elif recurse == 2 and is_tds is not None:
+                    return self.next_gateway(crm_id, date, step, click_id, processor, cc_type, recurse=recurse + 1,
+                                             is_tds=not is_tds, is_prepaid=is_prepaid)
+                return 'out of processing'
+            else:
+                # if len(decs) < 4:
+                #     return 'out of processing'
+                return 'declined due to too many attempts'
+        r = res.loc[res.fill_pct < 1]
+        if 'conversion_rate' not in res:
+            res['conversion_rate'] = 0
+        #  HARD CAP
+        if not len(r):
+
+            res = res.sort_values(['dly_initial_cap', 'conversion_rate'], ascending=[True, False]).sort_values(
+                ['fill_pct'])
+
+            def _get_aft_sc():
+                nonlocal res
+                if not len(res):
+                    return 'out of processing'
+                r2 = res.to_dict(orient='records')[0]
+                if r2['initial_count_mtd'] >= r2['monthly_initial_cap']:
+                    if cc_type == 'visa':
+                        #self.alert_cb('hard_cap_alert', crm_id=crm_id, gateway_id=r2['gateway_id'], cc_type=cc_type)
+                        # self.disable(crm_id=crm_id, gateway_id=r2['gateway_id'])
+                        res = res.loc[res.gateway_id != r2['gateway_id']]
+                    else:
+                        self.alert_cb('hard_cap_alert', crm_id=crm_id, gateway_id=r2['gateway_id'], cc_type='Non-Visa')
+                    return _get_aft_sc()
+                self.set_iin(**r2)
+                r2['is_tds'] = is_tds
+                return r2
+
+            # SOFT CAP
+            if ~res.soft_cap_alerted.any():
+                cnt = self.engine.execute(
+                    f"""select count(*) from  {self.schema}.{self.table}  
+                      where date = '{date}'::date and crm_id = '{crm_id}' 
+                      and router_id = '{step if step == 1 else 2}' 
+                      and enabled and enable_initials and fill_pct<1
+                      """).scalar()
+                if cnt == 0 or cnt is None:
+                    self.alert_cb('soft_cap_alert', crm_id=crm_id, cc_type=cc_type)
+                    self.set_soft_cap_alerted(crm_id, cc_type=cc_type)
+            return _get_aft_sc()
+        r = r.to_dict(orient='records')[0]
+        if cc_type:
+            r['cc_type'] = cc_type
+        if cc_first_8:
+            r['cc_first_8'] = cc_first_8
+
+        self.set_iin(**r)
+        r['is_tds'] = is_tds
+        return r

{modelswrkpi-8.1.3.dist-info → modelswrkpi-9.0.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: modelswrkpi
-Version: 8.1.3
+Version: 9.0.1
 Author: Kelly Kapowski
 Requires-Python: >=3.10
 Requires-Dist: psycopg2

{modelswrkpi-8.1.3.dist-info → modelswrkpi-9.0.1.dist-info}/RECORD

@@ -19,7 +19,7 @@ models/crm_errors.cpython-310-x86_64-linux-gnu.so,sha256=HOWYTHpij5vGEn6Y7_AEPSN
 models/custom_shipping.cpython-310-x86_64-linux-gnu.so,sha256=SopNkxl0GV2KjHTuFnsqUZwOGFq2nYebPWvgOZd9M2g,53584
 models/db.cpython-310-x86_64-linux-gnu.so,sha256=f9nmfnJ84IFkJk3QP9_Tm8q4lv2zGadUDsZr9NNCMWQ,470128
 models/discount_stats.cpython-310-x86_64-linux-gnu.so,sha256=jr0Gqkq2_TTHeaST-znR0BwC8bpfH5wUkd1f7PgZROk,65904
-models/discounter.cpython-310-x86_64-linux-gnu.so,sha256=Ntiyb6a343xBSwB9xJhYTa2AB-SFHAgW428lqVX06eI,563088
+models/discounter.cpython-310-x86_64-linux-gnu.so,sha256=dNpqpihh1Osrgowo5UpYW3HjQ5reX5eFvzuOeTnAD_4,563088
 models/email_reconfs.cpython-310-x86_64-linux-gnu.so,sha256=-x74-9M7uhxlepuhL1uKCDbh66ysddraneuf5xFYlHA,49456
 models/exception_log.cpython-310-x86_64-linux-gnu.so,sha256=R23bYTbB_4JycgfxRbVZhY-SJPka2Qpw-jt_M-4c8J4,53584
 models/filter_index.cpython-310-x86_64-linux-gnu.so,sha256=_MmKmoRDRQCesNaeZTLPALeRmevkVgee7paEUkDegik,61904
@@ -65,21 +65,22 @@ models/bro_clicks/error_log.cpython-310-x86_64-linux-gnu.so,sha256=I8fwpBrbxaB_A
 models/bro_clicks/initial_routes.cpython-310-x86_64-linux-gnu.so,sha256=JEM-67AUh3VsAJ9a_rH37jH4tCqdX-E6NMYgiLo9mHg,140368
 models/bro_clicks/scrub_settings.cpython-310-x86_64-linux-gnu.so,sha256=gKo6LHc-3OCQRl1SAg9XH6XMBJujLoB5F-6sYgKjTZ0,160592
 models/bro_clicks/splitter.cpython-310-x86_64-linux-gnu.so,sha256=27kzt-JDllwAXMFq8Xe2Av0RIDpwFK4h_t6BvytGsak,57712
-models/bro_clicks/load_balancer/__init__.py,sha256=h0UIw3AFm-gdyK-3xR1NgFKC95sJW1hz2Pw2dMdkA3A,370
-models/bro_clicks/load_balancer/compile.py,sha256=M1o0NKWcQe6b27e96PZlNUBBe8EFP5CnI3cWDamzquk,600
-models/bro_clicks/load_balancer/v1.cpython-310-x86_64-linux-gnu.so,sha256=IJa5FkmwEsQXh8ULGGjoP_hPbxkXWw1KABwmVV1YDUc,160656
-models/bro_clicks/load_balancer/v1.py,sha256=Df-LMtS0l0psJCyguSHtSIt_ofLwop55ogWDq3eFrig,8518
+models/bro_clicks/load_balancer/__init__.py,sha256=TMIh-RpmoCaEMTLU7geYtcDpygX5KFM8B4RRsHcKutA,432
+models/bro_clicks/load_balancer/compile.py,sha256=0mD0LCkkR2aasWk8AdxVA6ylHN28l4bV6vwkA2TUQF4,661
+models/bro_clicks/load_balancer/v1.cpython-310-x86_64-linux-gnu.so,sha256=iFWITw0tjieXWku8F2lg06n7Ar29r57AjA_ZUV35SO4,172976
+models/bro_clicks/load_balancer/v1.py,sha256=ikWbsxGFsYNTVbDGp43OvcbAGITFT9pt8JqEiq9zheI,10840
 models/bro_clicks/load_balancer/v2.cpython-310-x86_64-linux-gnu.so,sha256=VCGHr8KSipO2E0IfJ0zSpdte-xw_xsSK5vRWujtumnU,140368
 models/bro_clicks/load_balancer/v2.py,sha256=WSM6lKtyLrzx1xdhL3ncuH4QH-FBnS5Gm0uDFAtNHXo,7303
 models/bro_clicks/load_balancer/v3.cpython-310-x86_64-linux-gnu.so,sha256=f03MbM9KyuKpctvJ-6g6pnhMbnsasPtTkFVeQlRXUeA,256496
 models/bro_clicks/load_balancer/v3.py,sha256=-seP7t7dVO-O2q4I3wqgKrgTKxGPWVROHvSzVgwd_ug,16542
 models/bro_clicks/load_balancer/v4.cpython-310-x86_64-linux-gnu.so,sha256=kbQws2ObO2BxOOxjCaB7_H8IA1allHZ-zsX2kYMvrJo,136208
 models/bro_clicks/load_balancer/v4.py,sha256=wGe66SzYIa4qiPnA4ZZQ5tisvXv_j7XZZCVrsCG23Eg,7732
-models/bro_clicks/load_balancer/v5.cpython-310-x86_64-linux-gnu.so,sha256=VkmSqG11rgZTOv5AzhhVga52Ay6rrRKqmrrFVj8gUl0,127568
-models/bro_clicks/load_balancer/v5.py,sha256=GLRcbOUAI4n2m8wv7yGNhRZoPHQ8WO_Ra4FeAr3Yxsg,7755
-models/bro_clicks/load_balancer/v6.cpython-310-x86_64-linux-gnu.so,sha256=FHmp___9eteGe8pX_kHA5PDSIM7mLGkXhxWHg47imPc,165360
-models/bro_clicks/load_balancer/v6.py,sha256=Ekt-wML3bGadz1dOhDBC-L2WKrgzmRJc8ASTcY1rOgI,9608
-models/bro_clicks/load_balancer/v7.py,sha256=tkk6FpLgQvKCaFf2kmKsHhW_Pj4gJq4PcSe-DKcIUC4,264
+models/bro_clicks/load_balancer/v5.cpython-310-x86_64-linux-gnu.so,sha256=gHA2J0wZsH9XdQSa13aQQELgOET9qCieiTB5RaJgztQ,127568
+models/bro_clicks/load_balancer/v5.py,sha256=jA1KPoJLcm8szMGhaGuMSH-dZ6d0dwNv1PgGm0UHsJ0,8036
+models/bro_clicks/load_balancer/v6.cpython-310-x86_64-linux-gnu.so,sha256=1X_3SFmkafbH3Ejj8q7aHUHHxNzpP6zlJXNTKehks2s,165360
+models/bro_clicks/load_balancer/v6.py,sha256=oD_VYJ_Yvm5YJAGBx4IYxQHvIbKTeRq-Y00O38adOyQ,9587
+models/bro_clicks/load_balancer/v7.cpython-310-x86_64-linux-gnu.so,sha256=iGvt5u_PYzCMhf4MBbRWhH29sR-PyBSz7yAayf4qBVI,210064
+models/bro_clicks/load_balancer/v7.py,sha256=AJUdUt8vy4g639AAKaS5VWilfSOC74ycB3Pf471UOE0,18121
 models/bro_clicks/load_balancer/v8.py,sha256=tkk6FpLgQvKCaFf2kmKsHhW_Pj4gJq4PcSe-DKcIUC4,264
 models/cb911/__init__.py,sha256=Y3tX5WQYFUswdMMUpWqa9U_fNObUAhXcVrix3eXYP4k,64
 models/cb911/alerts.cpython-310-x86_64-linux-gnu.so,sha256=LCsUfaTzdQKS6ZaKQbfLCNTZbpZqaJmEsWDTUOdHUrI,61808
@@ -135,7 +136,7 @@ models/reports/table_reports/inactive_report.cpython-310-x86_64-linux-gnu.so,sha
 models/reports/table_reports/mtd_report.cpython-310-x86_64-linux-gnu.so,sha256=dHko7wWia9y9d-gIPC8uxycUnobII6hQgairSPRU168,74096
 models/vaultx/__init__.py,sha256=PwYMmWXQMojeyFnQuQW3wNlv9dLUmX_uiDfCOHJN7XI,46
 models/vaultx/ssc_cont.cpython-310-x86_64-linux-gnu.so,sha256=69kGuEko6oJEqxopS_4BxoX5S-Twq94eFwYJFEu_4B8,94992
-modelswrkpi-8.1.3.dist-info/METADATA,sha256=XCityP9r2Cx1HypVjO8vH3ZgKaxvq4AuHUoorH_6AqM,346
-modelswrkpi-8.1.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-modelswrkpi-8.1.3.dist-info/top_level.txt,sha256=fOgLNy4xnMfp0ihe_kFhY_yH71kNkdEQG68z8FoLR4g,19
-modelswrkpi-8.1.3.dist-info/RECORD,,
+modelswrkpi-9.0.1.dist-info/METADATA,sha256=eGnsJVZAHfaAtMyEqhIuUB3bPgfExeaEvjDkZm14RLI,346
+modelswrkpi-9.0.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+modelswrkpi-9.0.1.dist-info/top_level.txt,sha256=fOgLNy4xnMfp0ihe_kFhY_yH71kNkdEQG68z8FoLR4g,19
+modelswrkpi-9.0.1.dist-info/RECORD,,