Пример #1
0
 def __init__(self, data_provider, output, common):
     self.output = output
     self.data_provider = data_provider
     self.common = common
     self.project_name = self.data_provider.project_name
     self.session_uid = self.data_provider.session_uid
     self.products = self.data_provider[Data.PRODUCTS]
     self.all_products = self.data_provider[Data.ALL_PRODUCTS]
     self.match_product_in_scene = self.data_provider[Data.MATCHES]
     self.visit_date = self.data_provider[Data.VISIT_DATE]
     self.session_info = self.data_provider[Data.SESSION_INFO]
     self.scene_info = self.data_provider[Data.SCENES_INFO]
     self.store_id = self.data_provider[Data.STORE_FK]
     self.scif = self.data_provider[Data.SCENE_ITEM_FACTS]
     self.rds_conn = PSProjectConnector(self.project_name,
                                        DbUsers.CalculationEng)
     self.kpi_static_data = self.common.get_kpi_static_data()
     self.kpi_results_queries = []
     self.manufacturer_fk = self.products['manufacturer_fk'][
         self.products['manufacturer_name'] ==
         'MONDELEZ INTERNATIONAL INC'].iloc[0]
     self.store_assortment = pd.DataFrame()
     self.assortment = Assortment(self.data_provider, common=self.common)
     self.store_number = self.get_store_number()
     self.ps_data_provider = PsDataProvider(self.data_provider, self.output)
     self.custom_entities = self.ps_data_provider.get_custom_entities(
         Const.PPG_ENTITY_TYPE_FK)
Пример #2
0
 def __init__(self, data_provider, output, common):
     self.output = output
     self.data_provider = data_provider
     self.common = common
     self.templates_path = os.path.join(
         os.path.dirname(os.path.realpath(__file__)), '..', 'Data')
     self.excel_file_path = os.path.join(self.templates_path,
                                         'Template.xlsx')
     self.project_name = self.data_provider.project_name
     self.session_uid = self.data_provider.session_uid
     self.products = self.data_provider[Data.PRODUCTS]
     self.templates = self.data_provider[Data.TEMPLATES]
     self.all_products = self.data_provider[Data.ALL_PRODUCTS]
     self.scif = self.data_provider.scene_item_facts
     self.match_product_in_scene = self.data_provider[Data.MATCHES]
     self.visit_date = self.data_provider[Data.VISIT_DATE]
     self.session_info = self.data_provider[Data.SESSION_INFO]
     self.scene_info = self.data_provider[Data.SCENES_INFO]
     self.store_info = self.data_provider[Data.STORE_INFO]
     self.store_id = self.store_info.iloc[0].store_fk
     self.store_type = self.data_provider.store_type
     self.rds_conn = PSProjectConnector(self.project_name,
                                        DbUsers.CalculationEng)
     self.kpi_static_data = self.common.get_kpi_static_data()
     self.ps_data_provider = PsDataProvider(self.data_provider, self.output)
     self.targets = self.ps_data_provider.get_kpi_external_targets()
     self.empty_product_ids = self.all_products.query(
         'product_name.str.contains("empty", case=False) or'
         ' product_name.str.contains("irrelevant", case=False)',
         engine='python')['product_fk'].values
Пример #3
0
 def __init__(self, data_provider, output, commonV2, commonV1):
     self.output = output
     self.data_provider = data_provider
     self.common = commonV2
     self.commonV1 = commonV1
     self.project_name = self.data_provider.project_name
     self.session_uid = self.data_provider.session_uid
     self.products = self.data_provider[Data.PRODUCTS]
     self.all_products = self.data_provider[Data.ALL_PRODUCTS]
     self.match_product_in_scene = self.data_provider[Data.MATCHES]
     self.visit_date = self.data_provider[Data.VISIT_DATE]
     self.session_info = self.data_provider[Data.SESSION_INFO]
     self.scene_info = self.data_provider[Data.SCENES_INFO]
     self.store_id = self.data_provider[Data.STORE_FK]
     self.store_info = self.data_provider[Data.STORE_INFO]
     self.scif = self.data_provider[Data.SCENE_ITEM_FACTS]
     self.rds_conn = PSProjectConnector(self.project_name,
                                        DbUsers.CalculationEng)
     self.ps_data_provider = PsDataProvider(self.data_provider, self.output)
     self.kpi_static_data = self.common.get_kpi_static_data()
     self.old_kpi_static_data = self.commonV1.get_kpi_static_data()
     if not self.data_provider.scene_item_facts.empty:
         self.scene_results = self.ps_data_provider.get_scene_results(
             self.scene_info['scene_fk'].drop_duplicates().values)
     self.kpi_results_queries = []
     self.multiplier_template = pd.read_excel(
         self.TEMPLATE_PATH, sheetname=self.MULTIPLIER_SHEET)
 def __init__(self, data_provider, output, common):
     self.output = output
     self.data_provider = data_provider
     self.common = common
     self.project_name = self.data_provider.project_name
     self.session_uid = self.data_provider.session_uid
     self.products = self.data_provider[Data.PRODUCTS]
     self.templates = self.data_provider[Data.TEMPLATES]
     self.all_products = self.data_provider[Data.ALL_PRODUCTS]
     self.scif = self.data_provider.scene_item_facts
     self.match_product_in_scene = self.data_provider[Data.MATCHES]
     self.visit_date = self.data_provider[Data.VISIT_DATE]
     self.session_info = self.data_provider[Data.SESSION_INFO]
     self.scene_info = self.data_provider[Data.SCENES_INFO]
     self.store_info = self.data_provider[Data.STORE_INFO]
     self.store_id = self.store_info.iloc[0].store_fk
     self.store_type = self.data_provider.store_type
     self.rds_conn = PSProjectConnector(self.project_name,
                                        DbUsers.CalculationEng)
     self.kpi_static_data = self.common.get_kpi_static_data()
     self.ps_data_provider = PsDataProvider(self.data_provider, self.output)
     self.targets = self.load_external_targets()
     self.match_display_in_scene = self.data_provider.match_display_in_scene
     self.set_up_template = pd.read_excel(os.path.join(
         os.path.dirname(os.path.realpath(__file__)), '..', 'Data',
         'gsk_set_up.xlsx'),
                                          sheet_name='Functional KPIs',
                                          keep_default_na=False)
Пример #5
0
 def __init__(self, data_provider, output):
     self.output = output
     self.data_provider = data_provider
     self.ps_data_provider = PsDataProvider(data_provider)
     self.kpi_result_values = self.ps_data_provider.get_result_values()
     self.common_v2 = Common(self.data_provider)
     self.store_id = self.data_provider[Data.STORE_FK]
     self.scif = self.data_provider[Data.SCENE_ITEM_FACTS]
     self.assortment = Assortment(self.data_provider)
     self.own_manufacturer_fk = int(
         self.data_provider.own_manufacturer.param_value.values[0])
     self.kpi_static_data = self.common_v2.kpi_static_data[[
         'pk', StaticKpis.TYPE
     ]]
     # self.custom_entity = self.ps_data_provider.get_custom_entities(Consts.PRODUCT_GROUP)
     self.visit_date = self.data_provider[Data.VISIT_DATE]
     self.project_name = self.data_provider.project_name
     self.rds_conn = PSProjectConnector(self.project_name,
                                        DbUsers.CalculationEng)
     self.external_targets = self._retrieve_completeness_external_targets()
     self.products_trax_cat = self._get_products_with_trax_categories()
     self.ass_groups_present = {
         Consts.DISTR_SNACKS: 0,
         Consts.DISTR_SABRA: 0
     }
Пример #6
0
    def __init__(self, data_provider, output):
        self.output = output
        self.data_provider = data_provider
        self.common = Common(self.data_provider)
        self.project_name = self.data_provider.project_name
        self.session_uid = self.data_provider.session_uid
        self.products = self.data_provider[Data.PRODUCTS]
        self.all_products = self.data_provider[Data.ALL_PRODUCTS]
        self.match_product_in_scene = self.data_provider[Data.MATCHES]
        self.visit_date = self.data_provider[Data.VISIT_DATE]
        self.session_info = self.data_provider[Data.SESSION_INFO]
        self.scene_info = self.data_provider[Data.SCENES_INFO]
        self.store_id = self.data_provider[Data.STORE_FK]
        self.store_info = self.data_provider[Data.STORE_INFO]
        self.scif = self.data_provider[Data.SCENE_ITEM_FACTS]
        self.ps_data_provider = PsDataProvider(self.data_provider, self.output)
        self.manufacturer_fk = None if self.data_provider[Data.OWN_MANUFACTURER]['param_value'].iloc[0] is None else \
            int(self.data_provider[Data.OWN_MANUFACTURER]['param_value'].iloc[0])
        self.set_up_template = pd.read_excel(os.path.join(
            os.path.dirname(os.path.realpath(__file__)), '..', 'Data',
            'gsk_set_up.xlsx'),
                                             sheet_name='Functional KPIs',
                                             keep_default_na=False)

        self.gsk_generator = GSKGenerator(self.data_provider, self.output,
                                          self.common, self.set_up_template)
        self.targets = self.ps_data_provider.get_kpi_external_targets()
        self.sequence = Sequence(self.data_provider)
        self.set_up_data = {
            ('planogram', Const.KPI_TYPE_COLUMN): Const.NO_INFO,
            ('secondary_display', Const.KPI_TYPE_COLUMN): Const.NO_INFO,
            ('promo', Const.KPI_TYPE_COLUMN): Const.NO_INFO
        }
Пример #7
0
 def __init__(self, data_provider, output, common_db):
     self.output = output
     self.data_provider = data_provider
     self.project_name = self.data_provider.project_name
     self.session_uid = self.data_provider.session_uid
     self.products = self.data_provider[Data.PRODUCTS]
     self.all_products = self.data_provider[Data.ALL_PRODUCTS]
     self.match_product_in_scene = self.data_provider[Data.MATCHES]
     self.visit_date = self.data_provider[Data.VISIT_DATE]
     self.session_info = self.data_provider[Data.SESSION_INFO]
     self.scene_info = self.data_provider[Data.SCENES_INFO]
     self.store_id = self.data_provider[Data.STORE_FK]
     self.store_info = self.data_provider[Data.STORE_INFO]
     self.scif = self.data_provider[Data.SCENE_ITEM_FACTS]
     self.scif = self.scif[self.scif['product_type'] != "Irrelevant"]
     self.ps_data_provider = PsDataProvider(self.data_provider, self.output)
     self.templates = {}
     self.result_values = self.ps_data_provider.get_result_values()
     for sheet in Const.SHEETS:
         self.templates[sheet] = pd.read_excel(Const.TEMPLATE_PATH,
                                               sheetname=sheet).fillna('')
     self.common_db = common_db
     self.region = self.store_info['region_name'].iloc[0]
     self.store_type = self.store_info['store_type'].iloc[0]
     self.manufacturer_fk = Const.MANUFACTURER_FK
Пример #8
0
 def __init__(self, data_provider, output):
     self.output = output
     self.data_provider = data_provider
     self.common = Common(self.data_provider)
     self.match_display_in_scene = self.data_provider.match_display_in_scene
     self.project_name = self.data_provider.project_name
     self.session_uid = self.data_provider.session_uid
     self.products = self.data_provider[Data.PRODUCTS]
     self.all_products = self.data_provider[Data.ALL_PRODUCTS]
     self.scene_info = self.data_provider[Data.SCENES_INFO]
     self.templates = self.data_provider[Data.TEMPLATES]
     self.match_product_in_scene = self.data_provider[Data.MATCHES]
     self.visit_date = self.data_provider[Data.VISIT_DATE]
     self.session_info = self.data_provider[Data.SESSION_INFO]
     self.scene_info = self.data_provider[Data.SCENES_INFO]
     self.store_id = self.data_provider[Data.STORE_FK]
     self.scif = self.data_provider[Data.SCENE_ITEM_FACTS]
     self.rds_conn = PSProjectConnector(self.project_name, DbUsers.CalculationEng)
     self.ps_data_provider = PsDataProvider(self.data_provider, self.output)
     self.kpi_static_data = self.common.get_kpi_static_data()
     self.kpi_results_queries = []
     self.templates_path = os.path.join(os.path.dirname(os.path.realpath(__file__)), '..', 'Data')
     self.excel_file_path = os.path.join(self.templates_path, 'Template.xlsx')
     self.external_targets = self.ps_data_provider.get_kpi_external_targets(
         kpi_operation_types=["Target Config"],
         key_fields=["product_fks", "template_fks", "product_group_fk"],
         data_fields=["stacking_exclude", "min_product_facing", "best_shelf_position", "group_facings_count"]
         )
Пример #9
0
    def __init__(self, data_provider, output, common):
        self.data_provider = data_provider
        self.common = common
        self.project_name = self.data_provider.project_name
        self.session_uid = self.data_provider.session_uid
        self.templates = self.data_provider[Data.TEMPLATES]
        self.all_products = self.data_provider[Data.ALL_PRODUCTS]
        self.match_product_in_scene = self.data_provider[Data.MATCHES]
        empties = self.all_products[self.all_products['product_type'] ==
                                    'Empty']['product_fk'].unique().tolist()
        self.match_product_in_scene = self.match_product_in_scene[~(
            self.match_product_in_scene['product_fk'].isin(empties))]
        self.visit_date = self.data_provider[Data.VISIT_DATE]
        self.scene_info = self.data_provider[Data.SCENES_INFO]
        self.template_fk = self.templates['template_fk'].iloc[0]
        self.scene_id = self.scene_info['scene_fk'][0]
        self.store_id = self.data_provider[Data.STORE_INFO]['store_fk'][0]
        # self.kpi_fk = self.common.get_kpi_fk_by_kpi_name(Const.POC)
        self.all_brand = self.all_products[[
            'brand_name', 'brand_fk'
        ]].drop_duplicates().set_index(u'brand_name')
        self.displays_in_scene = self.data_provider.match_display_in_scene
        self.ps_data_provider = PsDataProvider(self.data_provider, output)

        # bit-like sequence to symoblize recognizing methods. Each 'bit' symbolize a recognition method.
        self.bitwise_for_program_identifier_as_list = list(
            "0" * self.BITWISE_RECOGNIZER_SIZE)
 def __init__(self, data_provider, output, common):
     self.output = output
     self.data_provider = data_provider
     self.common = common
     self.project_name = self.data_provider.project_name
     self.session_uid = self.data_provider.session_uid
     self.products = self.data_provider[Data.PRODUCTS]
     self.templates = self.data_provider[Data.TEMPLATES]
     self.all_products = self.data_provider[Data.ALL_PRODUCTS]
     self.scif = self.data_provider.scene_item_facts
     self.match_product_in_scene = self.data_provider[Data.MATCHES]
     self.visit_date = self.data_provider[Data.VISIT_DATE]
     self.session_info = self.data_provider[Data.SESSION_INFO]
     self.scene_info = self.data_provider[Data.SCENES_INFO]
     self.store_info = self.data_provider[Data.STORE_INFO]
     self.store_id = self.store_info.iloc[0].store_fk
     self.store_type = self.data_provider.store_type
     self.rds_conn = PSProjectConnector(self.project_name,
                                        DbUsers.CalculationEng)
     self.kpi_static_data = self.common.get_kpi_static_data()
     self.ps_data_provider = PsDataProvider(self.data_provider, self.output)
     self.targets = self.ps_data_provider.get_kpi_external_targets()
     self.match_display_in_scene = self.data_provider.match_display_in_scene
     self.setup_file = "setup.xlsx"
     self.kpi_sheet = self.get_setup(Consts.KPI_SHEET_NAME)
     self.kpi_template_file = "kpi_template.xlsx"
     self.kpi_template = self.get_kpi_template(Consts.KPI_CONFIG_SHEET)
     self.custom_entity = self.get_custom_entity()
     self.other_products = self.get_other_products()
Пример #11
0
 def __init__(self, data_provider, output):
     self.output = output
     self.data_provider = data_provider
     self.common = Common(self.data_provider)
     self.project_name = self.data_provider.project_name
     self.session_uid = self.data_provider.session_uid
     self.products = self.data_provider[Data.PRODUCTS]
     self.all_products = self.data_provider[Data.ALL_PRODUCTS]
     self.match_product_in_scene = self.data_provider[Data.MATCHES]
     self.visit_date = self.data_provider[Data.VISIT_DATE]
     self.session_info = self.data_provider[Data.SESSION_INFO]
     self.scene_info = self.data_provider[Data.SCENES_INFO]
     self.store_info = self.data_provider[Data.STORE_INFO]
     self.store_id = self.data_provider[Data.STORE_FK]
     self.scif = self.data_provider[Data.SCENE_ITEM_FACTS]
     self.rds_conn = PSProjectConnector(self.project_name,
                                        DbUsers.CalculationEng)
     self.match_probe_in_scene = self.get_product_special_attribute_data(
         self.session_uid)
     self.kpi_static_data = self.common.get_kpi_static_data()
     self.kpi_results_queries = []
     self.kpis_sheet = pd.read_excel(PATH, Const.KPIS).fillna("")
     self.osd_rules_sheet = pd.read_excel(PATH, Const.OSD_RULES).fillna("")
     self.kpi_excluding = pd.DataFrame()
     self.df = pd.DataFrame()
     self.tools = GENERALToolBox(self.data_provider)
     self.templates = self.data_provider[Data.ALL_TEMPLATES]
     self.psdataprovider = PsDataProvider(self.data_provider)
Пример #12
0
 def __init__(self, data_provider, output, common):
     self.output = output
     self.data_provider = data_provider
     self.common = common
     self.project_name = self.data_provider.project_name
     self.session_uid = self.data_provider.session_uid
     self.products = self.data_provider[Data.PRODUCTS]
     self.all_products = self.data_provider[Data.ALL_PRODUCTS]
     self.match_product_in_scene = self.data_provider[Data.MATCHES]
     self.visit_date = self.data_provider[Data.VISIT_DATE]
     self.session_info = self.data_provider[Data.SESSION_INFO]
     self.scene_info = self.data_provider[Data.SCENES_INFO]
     self.store_id = self.data_provider[Data.STORE_FK]
     self.scif = self.data_provider[Data.SCENE_ITEM_FACTS]
     self.rds_conn = PSProjectConnector(self.project_name,
                                        DbUsers.CalculationEng)
     self.kpi_static_data = self.common.get_kpi_static_data()
     self.new_kpi_static_data = self.common.get_new_kpi_static_data()
     self.kpi_results_queries = []
     self.template = pd.read_excel(self.TEMPLATE_PATH)
     self.ps_data_provider = PsDataProvider(self.data_provider, self.output)
     self.manual_collection_number = self.ps_data_provider.get_manual_collection_number(
     )
     self.custom_entities = self.ps_data_provider.get_custom_entities(
         self.FAMILY_BRAND)
Пример #13
0
 def __init__(self, data_provider, output, common_db):
     self.output = output
     self.data_provider = data_provider
     self.project_name = self.data_provider.project_name
     self.session_uid = self.data_provider.session_uid
     self.products = self.data_provider[Data.PRODUCTS]
     self.all_products = self.data_provider[Data.ALL_PRODUCTS]
     self.match_product_in_scene = self.data_provider[Data.MATCHES]
     self.visit_date = self.data_provider[Data.VISIT_DATE]
     self.session_info = self.data_provider[Data.SESSION_INFO]
     self.scene_info = self.data_provider[Data.SCENES_INFO]
     self.store_id = self.data_provider[Data.STORE_FK]
     self.ps_data_provider = PsDataProvider(self.data_provider, self.output)
     self.store_info = self.ps_data_provider.get_ps_store_info(
         self.data_provider[Data.STORE_INFO])
     self.scif = self.data_provider[Data.SCENE_ITEM_FACTS]
     self.scif = self.scif[self.scif['product_type'] != "Irrelevant"]
     self.result_values = self.ps_data_provider.get_result_values()
     self.templates = self.read_templates()
     self.common_db = common_db
     self.survey = Survey(self.data_provider, output=self.output, ps_data_provider=self.ps_data_provider,
                          common=self.common_db)
     self.manufacturer_fk = Const.MANUFACTURER_FK
     self.region = self.store_info['region_name'].iloc[0]
     self.store_type = self.store_info['store_type'].iloc[0]
     self.retailer = self.store_info['retailer_name'].iloc[0]
     self.branch = self.store_info['branch_name'].iloc[0]
     self.additional_attribute_4 = self.store_info['additional_attribute_4'].iloc[0]
     self.additional_attribute_7 = self.store_info['additional_attribute_7'].iloc[0]
     self.body_armor_delivered = self.get_body_armor_delivery_status()
     self.convert_base_size_and_multi_pack()
Пример #14
0
 def __init__(self, data_provider, output):
     self.output = output
     self.data_provider = data_provider
     self.common = Common(self.data_provider)
     self.project_name = self.data_provider.project_name
     self.session_uid = self.data_provider.session_uid
     self.all_products = self.data_provider[Data.ALL_PRODUCTS]
     self.visit_date = self.data_provider[Data.VISIT_DATE]
     self.session_info = self.data_provider[Data.SESSION_INFO]
     self.scene_info = self.data_provider[Data.SCENES_INFO]
     self.store_id = self.data_provider[Data.STORE_FK]
     self.ps_data_provider = PsDataProvider(self.data_provider, self.output)
     self.scenes = self.scene_info['scene_fk'].tolist()
     self.manufacturer_fk = int(
         self.data_provider[Data.OWN_MANUFACTURER]['param_value'].iloc[0])
     self.scif = self.data_provider[Data.SCENE_ITEM_FACTS]
     scenes_with_templates = self.scif[['template_name',
                                        'scene_fk']].drop_duplicates()
     exits = scenes_with_templates[
         scenes_with_templates['template_name'].str.contains(
             Const.EXIT_TEMPLATE)]['scene_fk'].tolist()
     entries = scenes_with_templates[
         scenes_with_templates['template_name'].str.contains(
             Const.ENTRY_TEMPLATE)]['scene_fk'].tolist()
     if self.scenes:
         self.scene_results = self.ps_data_provider.get_scene_results(
             self.scenes)
         self.exit_results = self.scene_results[
             self.scene_results["scene_fk"].isin(exits)]
         self.entry_results = self.scene_results[
             self.scene_results["scene_fk"].isin(entries)]
     else:
         self.scene_results = pd.DataFrame()
Пример #15
0
 def __init__(self, data_provider, output):
     self.output = output
     self.data_provider = data_provider
     self.project_name = self.data_provider.project_name
     self.session_uid = self.data_provider.session_uid
     self.products = self.data_provider[Data.PRODUCTS]
     self.all_products = self.data_provider[Data.ALL_PRODUCTS]
     self.match_product_in_scene = self.data_provider[Data.MATCHES]
     self.visit_date = self.data_provider[Data.VISIT_DATE]
     self.session_info = self.data_provider[Data.SESSION_INFO]
     self.scene_info = self.data_provider[Data.SCENES_INFO]
     self.store_id = self.data_provider[Data.STORE_FK]
     self.scif = self.data_provider[Data.SCENE_ITEM_FACTS]
     self.rds_conn = PSProjectConnector(self.project_name, DbUsers.CalculationEng)
     self.tools = RBUSGENERALToolBox(self.data_provider, self.output, rds_conn=self.rds_conn)
     self.old_common = common_old(data_provider)
     self.kpi_static_data = self.old_common.get_kpi_static_data()
     # self.kpi_results_queries = []
     self.templates_path = os.path.join(os.path.dirname(os.path.realpath(__file__)), '..', 'Data')
     self.template_dict = self.get_df_from_excel_path()
     self.template_dict = self.template_dict[self.template_dict['Template for KPI'] != 'none']\
                                             .set_index('Template for KPI')['KPI Level 3 Name'].to_dict()
     self.excluded_sub_categories = self.get_excluded_sub_categories(self.get_df_from_excel_path())
     self.common_new = Common(data_provider)
     self.manufacturer_fk = self.data_provider[Data.OWN_MANUFACTURER]['param_value'].iloc[0]
     self.ps_data = PsDataProvider(self.data_provider, self.output)
     self.templates = self.data_provider[Data.TEMPLATES]
     self.sub_brands = self.ps_data.get_custom_entities(1001)
Пример #16
0
 def __init__(self, data_provider, output):
     self.k_engine = BaseCalculationsScript(data_provider, output)
     self.output = output
     self.data_provider = data_provider
     self.project_name = self.data_provider.project_name
     self.session_uid = self.data_provider.session_uid
     self.products = self.data_provider[Data.PRODUCTS]
     self.all_products = self.data_provider[Data.ALL_PRODUCTS]
     self.match_product_in_scene = self.data_provider[Data.MATCHES]
     self.visit_date = self.data_provider[Data.VISIT_DATE]
     self.session_info = self.data_provider[Data.SESSION_INFO]
     self.scene_info = self.data_provider[Data.SCENES_INFO]
     self.store_id = self.data_provider[Data.STORE_FK]
     self.store_info = self.data_provider[Data.STORE_INFO]
     self.store_type = self.store_info['store_type'].iloc[0]
     self.scif = self.data_provider[Data.SCENE_ITEM_FACTS]
     self.rds_conn = PSProjectConnector(self.project_name, DbUsers.CalculationEng)
     self.general_tools = CCKHGENERALToolBox(self.data_provider, self.output)
     self.template = CCKHTemplateConsts()
     self.kpi_static_data = self.get_kpi_static_data()
     self.kpi_results_queries = []
     self.commonV2 = CommonV2(self.data_provider)
     self.kpi_new_static_data = self.commonV2.get_new_kpi_static_data()
     self.manufacturer = int(self.data_provider.own_manufacturer.param_value.values[0])
     self.ps_data_provider = PsDataProvider(self.data_provider, self.output)
     self.external_targets = self.ps_data_provider.get_kpi_external_targets()
     self.assortment = Assortment(self.data_provider, self.output)
     self.templates_info = self.external_targets[self.external_targets[CCKHTemplateConsts.TEMPLATE_OPERATION] ==
                                                 CCKHTemplateConsts.BASIC_SHEET]
     self.visibility_info = self.external_targets[self.external_targets[CCKHTemplateConsts.TEMPLATE_OPERATION]
                                                  == CCKHTemplateConsts.VISIBILITY_SHEET]
     self.cooler_info = self.external_targets[self.external_targets[CCKHTemplateConsts.TEMPLATE_OPERATION]
                                              == CCKHTemplateConsts.COOLER_SHEET]
 def __init__(self, data_provider, output, common, exclusive_template):
     self.output = output
     self.data_provider = data_provider
     self.project_name = self.data_provider.project_name
     self.session_uid = self.data_provider.session_uid
     self.session_id = self.data_provider.session_id
     self.products = self.data_provider[Data.PRODUCTS]
     self.all_products_i_d = self.data_provider[
         Data.ALL_PRODUCTS_INCLUDING_DELETED]
     self.all_products = self.data_provider[Data.ALL_PRODUCTS]
     self.match_product_in_scene = self.data_provider[Data.MATCHES]
     self.visit_date = self.data_provider[Data.VISIT_DATE]
     self.session_info = self.data_provider[Data.SESSION_INFO]
     self.scene_info = self.data_provider[Data.SCENES_INFO]
     self.store_id = self.data_provider[Data.STORE_FK]
     self.scif = self.data_provider[Data.SCENE_ITEM_FACTS]
     self.templates = self.data_provider[Data.ALL_TEMPLATES]
     self.survey_response = self.data_provider[Data.SURVEY_RESPONSES]
     self.rds_conn = PSProjectConnector(self.project_name,
                                        DbUsers.CalculationEng)
     self.tools = JNJGENERALToolBox(self.data_provider,
                                    self.output,
                                    rds_conn=self.rds_conn)
     self.ps_data_provider = PsDataProvider(self.data_provider, self.output)
     self.common = common
     self.New_kpi_static_data = common.get_new_kpi_static_data()
     self.kpi_results_new_tables_queries = []
     self.all_products = self.ps_data_provider.get_sub_category(
         self.all_products, 'sub_category_local_name')
     self.store_info = self.data_provider[Data.STORE_INFO]
     self.store_info = self.ps_data_provider.get_ps_store_info(
         self.store_info)
     self.current_date = datetime.now()
     self.labels = self.ps_data_provider.get_labels()
     self.products_in_ass = []
     self.products_to_ass = pd.DataFrame(
         columns=assTemplate.COLUMNS_ASSORTMENT_DEFINITION_SHEET)
     self.assortment_policy = pd.DataFrame(
         columns=assTemplate.COLUMNS_STORE_ATTRIBUTES_TO_ASSORT)
     self.ass_deleted_prod = pd.DataFrame(columns=[
         assTemplate.COLUMN_GRANULAR_GROUP, assTemplate.COLUMN_EAN_CODE
     ])
     self.session_category_info = pd.DataFrame()
     self.session_products = pd.DataFrame()
     self.assortment = Assortment(self.data_provider, self.output,
                                  self.ps_data_provider)
     self.products_to_remove = []
     self.ignore_from_top = 1
     self.start_shelf = 3
     self.products_for_ass_new = pd.DataFrame(
         columns=['session_id', 'product_fk'])
     self.prev_session_products_new_ass = pd.DataFrame()
     self.session_category_new_ass = pd.DataFrame()
     self.own_manuf_fk = int(
         self.data_provider.own_manufacturer.param_value.values[0])
     self.kpi_result_values = self.get_kpi_result_values_df()
     self.parser = Parser
     self.exclusive_template = exclusive_template
     self.result_values = self.ps_data_provider.get_result_values()
Пример #18
0
    def __init__(self, data_provider, output):
        self.output = output
        self.data_provider = data_provider
        self.common = Common(self.data_provider)
        self.common_v2 = CommonV2(self.data_provider)
        self.project_name = self.data_provider.project_name
        self.session_uid = self.data_provider.session_uid
        self.products = self.data_provider[Data.PRODUCTS]
        self.all_products = self.data_provider[Data.ALL_PRODUCTS]
        self.match_product_in_scene = self.data_provider[Data.MATCHES]
        self.visit_date = self.data_provider[Data.VISIT_DATE]
        self.session_info = self.data_provider[Data.SESSION_INFO]
        self.scene_info = self.data_provider[Data.SCENES_INFO]
        self.store_id = self.data_provider[Data.STORE_FK]
        self.scif = self.data_provider[Data.SCENE_ITEM_FACTS]
        self.template_info = self.data_provider.all_templates
        self.rds_conn = ProjectConnector(self.project_name,
                                         DbUsers.CalculationEng)
        self.ps_data_provider = PsDataProvider(self.data_provider)
        self.thresholds_and_results = {}
        self.result_df = []
        self.writing_to_db_time = datetime.timedelta(0)
        self.kpi_results_queries = []
        self.potential_products = {}
        self.shelf_square_boundaries = {}
        self.average_shelf_values = {}
        self.kpi_static_data = self.common.get_kpi_static_data()
        self.kpi_results_queries = []
        self.all_template_data = parse_template(TEMPLATE_PATH, "KPI")
        self.spacing_template_data = parse_template(TEMPLATE_PATH, "Spacing")
        self.fixture_width_template = pd.read_excel(FIXTURE_WIDTH_TEMPLATE,
                                                    "Fixture Width",
                                                    dtype=pd.Int64Dtype())
        self.facings_to_feet_template = pd.read_excel(FIXTURE_WIDTH_TEMPLATE,
                                                      "Conversion Table",
                                                      dtype=pd.Int64Dtype())
        self.header_positions_template = pd.read_excel(FIXTURE_WIDTH_TEMPLATE,
                                                       "Header Positions")
        self.flip_sign_positions_template = pd.read_excel(
            FIXTURE_WIDTH_TEMPLATE, "Flip Sign Positions")
        self.custom_entity_data = self.ps_data_provider.get_custom_entities(
            1005)
        self.ignore_stacking = False
        self.facings_field = 'facings' if not self.ignore_stacking else 'facings_ign_stack'
        self.INCLUDE_FILTER = 1
        self.assortment = Assortment(self.data_provider,
                                     output=self.output,
                                     ps_data_provider=self.ps_data_provider)
        self.store_assortment = self.assortment.get_lvl3_relevant_ass()

        self.kpi_new_static_data = self.common.get_new_kpi_static_data()
        try:
            self.mpis = self.match_product_in_scene.merge(self.products, on='product_fk', suffixes=['', '_p']) \
                        .merge(self.scene_info, on='scene_fk', suffixes=['', '_s']) \
                          .merge(self.template_info, on='template_fk', suffixes=['', '_t'])
        except KeyError:
            Log.warning('MPIS cannot be generated!')
            return
        self.adp = AltriaDataProvider(self.data_provider)
Пример #19
0
 def __init__(self, data_provider, output):
     GlobalSessionToolBox.__init__(self, data_provider, output)
     self.assortment = Assortment(data_provider)
     self.ps_data = PsDataProvider(data_provider)
     self.display_in_scene = data_provider.match_display_in_scene
     self.static_display = data_provider.static_display
     self.manufacturer_fk = int(self.manufacturer_fk)
     self._add_display_data_to_scif()
     self._add_client_name_and_sub_brand_data()
Пример #20
0
 def __init__(self, data_provider, output):
     GlobalSessionToolBox.__init__(self, data_provider, output)
     self.own_manufacturer_fk = int(self.data_provider.own_manufacturer.param_value.values[0])
     self.parser = Parser
     self.all_products = self.data_provider[Data.ALL_PRODUCTS]
     self.assortment = Assortment(self.data_provider, self.output)
     self.ps_data = PsDataProvider(self.data_provider, self.output)
     self.kpi_external_targets = self.ps_data.get_kpi_external_targets(key_fields=Consts.KEY_FIELDS,
                                                                       data_fields=Consts.DATA_FIELDS)
Пример #21
0
 def __init__(self, data_provider, output):
     GlobalSessionToolBox.__init__(self, data_provider, output)
     self.adjacency = Adjancency(data_provider)
     self.block = Block(data_provider)
     self.kpi_static_data = self.common.get_kpi_static_data()
     self.ps_data_provider = PsDataProvider(data_provider)
     self._scene_types = None
     self.external_targets = self.ps_data_provider.get_kpi_external_targets(
     )
Пример #22
0
 def __init__(self, data_provider, output, calculation_type, common_db2):
     self.output = output
     self.data_provider = data_provider
     self.project_name = self.data_provider.project_name
     self.session_uid = self.data_provider.session_uid
     self.products = self.data_provider[Data.PRODUCTS]
     self.all_products = self.data_provider[Data.ALL_PRODUCTS]
     self.match_product_in_scene = self.data_provider[Data.MATCHES]
     self.visit_date = self.data_provider[Data.VISIT_DATE]
     self.session_info = self.data_provider[Data.SESSION_INFO]
     self.scene_info = self.data_provider[Data.SCENES_INFO]
     self.store_id = self.data_provider[Data.STORE_FK]
     self.store_info = self.data_provider[Data.STORE_INFO]
     self.scif = self.data_provider[Data.SCENE_ITEM_FACTS]
     self.scif = self.scif[self.scif['product_type'] != "Irrelevant"]
     self.ps_data_provider = PsDataProvider(self.data_provider, self.output)
     self.templates = {}
     self.result_values = self.ps_data_provider.get_result_values()
     self.calculation_type = calculation_type
     if self.calculation_type == Const.SOVI:
         self.TEMPLATE_PATH = Const.TEMPLATE_PATH
         self.RED_SCORE = Const.RED_SCORE
         self.RED_SCORE_INTEG = Const.RED_SCORE_INTEG
         for sheet in Const.SHEETS:
             self.templates[sheet] = pd.read_excel(self.TEMPLATE_PATH, sheetname=sheet).fillna('')
         self.converters = self.templates[Const.CONVERTERS]
         self.scenes_results = self.ps_data_provider.get_scene_results(
             self.scene_info['scene_fk'].drop_duplicates().values)
         self.scenes_results = self.scenes_results[[Const.DB_RESULT, Const.DB_SCENE_FK, Const.DB_SCENE_KPI_FK]]
     else:
         self.TEMPLATE_PATH = Const.SURVEY_TEMPLATE_PATH
         self.RED_SCORE = Const.MANUAL_RED_SCORE
         self.RED_SCORE_INTEG = Const.MANUAL_RED_SCORE_INTEG
         for sheet in Const.SHEETS_MANUAL:
             self.templates[sheet] = pd.read_excel(self.TEMPLATE_PATH, sheetname=sheet).fillna('')
     self.store_attr = self.store_info['additional_attribute_15'].iloc[0]
     self.toolbox = FunctionsToolBox(self.data_provider, self.output, self.templates, self.store_attr)
     self.common_db_integ = Common(self.data_provider, self.RED_SCORE_INTEG)
     self.kpi_static_data_integ = self.common_db_integ.get_kpi_static_data()
     self.common_db = Common(self.data_provider, self.RED_SCORE)
     self.common_db2 = common_db2
     self.region = self.store_info['region_name'].iloc[0]
     self.store_type = self.store_info['store_type'].iloc[0]
     if self.store_type in Const.STORE_TYPES:
         self.store_type = Const.STORE_TYPES[self.store_type]
     self.kpi_static_data = self.common_db.get_kpi_static_data()
     main_template = self.templates[Const.KPIS]
     self.templates[Const.KPIS] = main_template[(main_template[Const.REGION] == self.region) &
                                                (main_template[Const.STORE_TYPE] == self.store_type)]
     self.session_results = pd.DataFrame(columns=Const.COLUMNS_OF_RESULTS)
     self.all_results = pd.DataFrame(columns=Const.COLUMNS_OF_RESULTS)
     self.used_scenes = []
     self.red_score = 0
     self.set_fk = self.common_db2.get_kpi_fk_by_kpi_name(self.RED_SCORE)
     self.set_integ_fk = self.common_db2.get_kpi_fk_by_kpi_name(self.RED_SCORE_INTEG)
     self.weight_factor = self.get_weight_factor()
 def __init__(self, data_provider, output):
     GlobalSceneToolBox.__init__(self, data_provider, output)
     self.ps_data_provider = PsDataProvider(self.data_provider, self.output)
     self.rds_conn = PSProjectConnector(self.project_name, DbUsers.CalculationEng)
     self.targets = self.ps_data_provider.get_kpi_external_targets(key_fields=['KPI Type'], data_fields=[
                                                                                'Location: JSON',
                                                                                'Config Params: JSON',
                                                                                'Dataset 1: JSON'])
     self.gold_zone_scene_location_kpi = ['Lobby/Entrance', 'Main Alley/Hot Zone', 'Gold Zone End Cap',
                                          'Lobby/Main Entrance']
Пример #24
0
    def __init__(self, output, data_provider):
        super(PepsicoUtil, self).__init__(data_provider)
        self.output = output
        self.common = Common(self.data_provider)
        # self.common_v1 = CommonV1(self.data_provider)
        self.project_name = self.data_provider.project_name
        self.session_uid = self.data_provider.session_uid
        self.products = self.data_provider[Data.PRODUCTS]
        self.all_products = self.data_provider[Data.ALL_PRODUCTS]
        self.match_product_in_scene = self.data_provider[Data.MATCHES]
        self.visit_date = self.data_provider[Data.VISIT_DATE]
        self.session_info = self.data_provider[Data.SESSION_INFO]
        self.scene_info = self.data_provider[Data.SCENES_INFO]
        self.store_id = self.data_provider[Data.STORE_FK] if self.data_provider[Data.STORE_FK] is not None \
                                                            else self.session_info['store_fk'].values[0]
        self.scif = self.data_provider[Data.SCENE_ITEM_FACTS]
        self.rds_conn = PSProjectConnector(self.project_name, DbUsers.CalculationEng)
        self.display_scene = self.get_match_display_in_scene()
        self.kpi_static_data = self.common.get_kpi_static_data()
        self.kpi_results_queries = []

        self.probe_groups = self.get_probe_group()
        self.match_product_in_scene = self.match_product_in_scene.merge(self.probe_groups, on='probe_match_fk',
                                                                        how='left')

        self.toolbox = GENERALToolBox(self.data_provider)
        self.commontools = PEPSICOUKCommonToolBox(self.data_provider, self.rds_conn)

        self.all_templates = self.commontools.all_templates
        self.custom_entities = self.commontools.custom_entities
        self.on_display_products = self.commontools.on_display_products
        self.exclusion_template = self.commontools.exclusion_template
        self.filtered_scif = self.commontools.filtered_scif.copy()
        self.filtered_matches = self.commontools.filtered_matches.copy()
        self.filtered_matches = self.filtered_matches.merge(self.probe_groups, on='probe_match_fk', how='left')

        self.filtered_scif_secondary = self.commontools.filtered_scif_secondary.copy()
        self.filtered_matches_secondary = self.commontools.filtered_matches_secondary.copy()

        self.scene_bay_shelf_product = self.commontools.scene_bay_shelf_product
        self.ps_data = PsDataProvider(self.data_provider, self.output)
        self.full_store_info = self.commontools.full_store_info.copy()
        self.external_targets = self.commontools.external_targets
        self.assortment = Assortment(self.commontools.data_provider, self.output)
        self.lvl3_ass_result = self.get_lvl3_relevant_assortment_result()
        self.own_manuf_fk = self.all_products[self.all_products['manufacturer_name'] == self.PEPSICO]['manufacturer_fk'].values[0]

        self.scene_kpi_results = self.get_results_of_scene_level_kpis()
        self.kpi_results_check = pd.DataFrame(columns=['kpi_fk', 'numerator', 'denominator', 'result', 'score',
                                                       'context'])
        self.sos_vs_target_targets = self.construct_sos_vs_target_base_df()

        self.all_targets_unpacked = self.commontools.all_targets_unpacked.copy()
        self.block_results = pd.DataFrame(columns=['Group Name', 'Score'])
        self.hero_type_custom_entity_df = self.get_hero_type_custom_entity_df()
 def __init__(self, data_provider, common):
     GlobalSessionToolBox.__init__(self, data_provider, None)
     self.filtered_mdis = self._get_filtered_match_display_in_scene()
     self.store_number_1 = self.store_info.store_number_1[0]
     self.filtered_scif = self._get_filtered_scif()
     self.ps_data_provider = PsDataProvider(data_provider)
     self.target = self._get_case_count_targets()
     self.matches = self.get_filtered_matches()
     self.excluded_product_fks = self._get_excluded_product_fks()
     self.adj_graphs_per_scene = {}
     self.common = common
Пример #26
0
    def __init__(self, data_provider, common):
        GlobalSessionToolBox.__init__(self, data_provider, None)
        # self.matches = self.get_filtered_matches()
        self.store_number = self.store_info.store_number_1.iloc[0]
        self.ps_data_provider = PsDataProvider(self.data_provider, self.output)
        self.rds_conn = PSProjectConnector(self.project_name, DbUsers.CalcAdmin)
        self.custom_entity = self.get_custom_entity()

        self.targets = self.ps_data_provider.get_kpi_external_targets(kpi_fks=[6006],
                                                                      key_fields=['store_number_1', 'product_fk'],
                                                                      key_filters={'store_number_1': self.store_number})
        self.common = common
Пример #27
0
 def __init__(self, data_provider, output, common):
     GlobalSessionToolBox.__init__(self, data_provider, output, common)
     self.scene_types = self.scif['template_name'].unique().tolist()
     self.gz = self.store_info['additional_attribute_4'].iloc[0]
     self.city = self.store_info['address_city'].iloc[0]
     self.relevant_targets = self._get_relevant_external_targets(
         kpi_operation_type='acomodo_cigarros')
     self.invasion_targets = self._get_relevant_external_targets(
         kpi_operation_type='invasion')
     self._determine_target_product_fks()
     self.leading_products = self._get_leading_products_from_scif()
     self.scene_realograms = self._calculate_scene_realograms()
     self.ps_data_provider = PsDataProvider(self.data_provider)
     self.match_product_in_probe_state_reporting = self.ps_data_provider.get_match_product_in_probe_state_reporting(
     )
Пример #28
0
class Shared():
    def __init__(self, data_provider, output):
        self.data_provider = data_provider
        self.output = output
        self.ps_data_provider = PsDataProvider(self.data_provider, self.output)
        self.result_values = self.ps_data_provider.get_result_values(
        ).set_index('value')['pk'].to_dict()

    @staticmethod
    def sos_with_num_and_dem(kpi_line, num_scif, den_scif, facings_field):

        try:
            Validation.is_empty_df(den_scif)
            Validation.df_columns_equality(den_scif, num_scif)
            Validation.is_subset(den_scif, num_scif)
        except Exception, e:
            msg = "Data verification failed: {}.".format(e)
            # raise Exception(msg)
            # print(msg)
            return None, None, None

        den = den_scif[facings_field].sum()

        try:
            Validation.is_empty_df(num_scif)
        except Exception as e:
            return (0, 0, den)

        num = num_scif[facings_field].sum()
        if den:
            ratio = round((num / float(den)) * 100, 2)
        else:
            ratio = 0

        return ratio, num, den
Пример #29
0
    def __init__(self, data_provider, output, common):
        GlobalSessionToolBox.__init__(self, data_provider, output, common)
        self.ps_data_provider = PsDataProvider(data_provider)
        self.own_manufacturer = int(self.data_provider.own_manufacturer.param_value.values[0])
        self.all_templates = self.data_provider[Data.ALL_TEMPLATES]
        self.project_templates = {}
        self.parse_template()
        self.store_type = self.store_info['store_type'].iloc[0]
        self.survey = Survey(self.data_provider, output, ps_data_provider=self.ps_data_provider, common=self.common)
        self.att2 = self.store_info['additional_attribute_2'].iloc[0]
        self.results_df = pd.DataFrame(columns=['kpi_name', 'kpi_fk', 'numerator_id', 'numerator_result',
                                                'denominator_id', 'denominator_result', 'result', 'score',
                                                'identifier_result', 'identifier_parent', 'should_enter'])

        self.products = self.data_provider[Data.PRODUCTS]
        scif = self.scif[['brand_fk', 'facings', 'product_type']].groupby(by='brand_fk').sum()
        self.mpis = self.matches \
            .merge(self.products, on='product_fk', suffixes=['', '_p']) \
            .merge(self.scene_info, on='scene_fk', suffixes=['', '_s']) \
            .merge(self.all_templates[['template_fk', TEMPLATE_GROUP]], on='template_fk') \
            .merge(scif, on='brand_fk')[COLUMNS]
        self.mpis['store_fk'] = self.store_id

        self.calculations = {
            COMBO: self.calculate_combo,
            POSM_AVAILABILITY: self.calculate_posm_availability,
            SCORING: self.calculate_scoring,
            SHARE_OF_EMPTY: self.calculate_share_of_empty,
            SOS: self.calculate_sos,
            SURVEY: self.calculate_survey,
        }
Пример #30
0
 def __init__(self, data_provider, output):
     GlobalSessionToolBox.__init__(self, data_provider, output)
     self.ps_data_provider = PsDataProvider(self.data_provider, self.output)
     self.results_df = pd.DataFrame(columns=[
         'kpi_name', 'kpi_fk', 'numerator_id', 'numerator_result',
         'denominator_id', 'denominator_result', 'result', 'score',
         'identifier_result', 'identifier_parent', 'should_enter', 'target'
     ])
     self.templates = {}
     self.parse_template()
     self.own_manuf_fk = int(
         self.data_provider.own_manufacturer.param_value.values[0])
     self.scif = self.scif[self.scif['product_type'] != 'Irrelevant']
     self.scene_survey_results = self.get_scene_survey_response()
     self.session_survey_results = self.get_session_survey_response()
     self.custom_entities = self.ps_data_provider.get_custom_entities(1002)