17/replication_package/code/data/source/build_master/builder.py

from datetime import datetime,timedelta
import pandas as pd
import os
import sys
import git
from pympler.tracker import SummaryTracker

#importing modules from root of data
root = git.Repo('.', search_parent_directories = True).working_tree_dir
sys.path.append(root)
os.chdir(os.path.join(root))

from lib.data_helpers.pull_events import PullEvents
from lib.utilities import serialize
from data.source.build_master.pullers.pull_events_use import PullEventsUse
from data.source.build_master.pullers.pull_events_alt import PullEventsAlt


from lib.data_helpers.clean_events import CleanEvents
from data.source.build_master.cleaners.clean_surveys import CleanSurveys
from data.source.build_master.cleaners.clean_events_use import CleanEventsUse
from data.source.build_master.cleaners.clean_events_status import CleanEventsStatus
from data.source.build_master.cleaners.clean_events_budget import CleanEventsBudget
from data.source.build_master.cleaners.clean_events_snooze_delays import CleanEventsSnoozeDelays
from data.source.build_master.cleaners.clean_events_snooze import CleanEventsSnooze
from data.source.build_master.cleaners.clean_events_alt import CleanEventsAlt




from lib.data_helpers.gaming import Gaming
from data.source.build_master.master_raw_user import MasterRawUser
from data.source.build_master.master_raw_user_day_app import MasterRawUserDayApp

from lib.experiment_specs import study_config

"""

"""
class Builder():

    @staticmethod
    def build_master():
        tracker = SummaryTracker()

        # print(f"\n Clean Survey Data {datetime.now()}")
        # clean_surveys = CleanSurveys.clean_all_surveys()

        # print(f"\nInitializing Master DF and add survey data {datetime.now()}")
        # raw_user = MasterRawUser(initial_survey_df= clean_surveys[study_config.initial_master_survey])
        # raw_user.add(clean_surveys)
        # del clean_surveys

        # print(f"\nCleaning Traditional Use and DetectGaming {datetime.now()}")
        # trad_use_phase, trad_use_hour = Builder._build_pd_use()

        # game_df = Gaming.process_gaming(error_margin=1,
        #                                 hour_use=trad_use_hour,
        #                                 raw_user_df=raw_user.raw_master_df)
        # raw_user.add({"Game": game_df})

        # tracker.print_diff()
        # del [trad_use_phase, game_df]
        # tracker.print_diff()

        # if datetime.now() > study_config.surveys["Midline"]["Start"]:
        #     print(f"\nCleaning Limit Data {datetime.now()}")
        #     pd_snooze = Builder._build_pd_snooze()
        #     budget_phase, pd_budget = Builder._build_pd_budget()
        #     try:
        #         Builder._build_pd_snooze_delay()
        #     except:
        #         print("couldn't process snooze delay data")

        #     raw_user.add({"PDBudget": budget_phase})
        # else:
        #     pd_budget = pd.DataFrame()
        #     pd_snooze = pd.DataFrame()

        print(f"\nCleaning Traditional Use Individual {datetime.now()}")
        Builder._build_pd_use_indiv()

        # print(f"\n Alternative and Status Data {datetime.now()}")
        # alt_use_hour, alt_use_phase = Builder._build_pd_alt(trad_use_hour)
        # raw_user.add({"AltPDUse": alt_use_phase})

        # clean_status, pd_latest = Builder._build_pd_status(raw_user.raw_master_df,alt_use_hour)
        # raw_user.add({"LatestPD": pd_latest})
        # del [alt_use_phase, pd_latest]

        # print(f"\n Serialize user level data before building user-app-day data")
        # config_user_dict = serialize.open_yaml("config_user.yaml")
        # if config_user_dict['local']['test'] == False:
        #     serialize.save_pickle(raw_user.raw_master_df,
        #                           os.path.join("data", "external", "intermediate", "MasterIntermediateUser"))

        # print(f"\n Create UserXAppXDate Level data {datetime.now()}")
        # MasterRawUserDayApp.build(alt_use_hour,pd_budget,pd_snooze,clean_status)

        # tracker.print_diff()
        # del [pd_budget,pd_snooze,alt_use_hour]

        # print(f"\n Recover Old Install Data")
        # PullEventsAlt.recover_install_data()
        # return raw_user.raw_master_df


    @staticmethod
    def _build_pd_use():
        pd_use_puller = PullEvents(source="PhoneDashboard",
                                    keyword="Use",
                                    scratch=False,
                                    test=False,
                                    time_cols=["Created", "Recorded"],
                                    raw_timezone="Local",
                                    appcode_col='Source',
                                    identifying_cols=["AppCode", "ForegroundApp", "ScreenActive",
                                                      "CreatedDatetimeHour"],
                                    sort_cols= ["CreatedDatetimeHour","RecordedDatetimeHour"],
                                    drop_cols= ["PlayStoreCategory","UploadLag"],
                                    cat_cols = ["ForegroundApp"],
                                    compress_type="txt",
                                    processing_func=PullEventsUse.process_raw_use)

        raw_hour_use = pd_use_puller.update_data()

        use_cleaner = CleanEvents(source="PhoneDashboard", keyword="Use")
        use_phase, use_hour = use_cleaner.clean_events(raw_event_df=raw_hour_use,
                                                date_col="CreatedDate",
                                                cleaner=CleanEventsUse(use_type="Traditional"))

        CleanEventsUse.get_timezones(use_hour, "CreatedDatetimeHour", "CreatedEasternDatetimeHour")


        return use_phase, use_hour

    @staticmethod
    def _build_pd_use_indiv():
        pd_use_puller = PullEvents(source="PhoneDashboard",
                                    keyword="UseIndiv",
                                    scratch=True,
                                    test=False,
                                    time_cols=["Created", "Recorded"],
                                    raw_timezone="Local",
                                    appcode_col='Source',
                                    identifying_cols=["AppCode", "ForegroundApp", "StartTime", "UseMinutes"],
                                    sort_cols= ["StartTime"],
                                    drop_cols= ["PlayStoreCategory","UploadLag"],
                                    cat_cols = ["ForegroundApp"],
                                    compress_type="txt",
                                    processing_func=PullEventsUse.process_raw_use_indiv)

        raw_hour_use = pd_use_puller.update_data()

        # use_cleaner = CleanEvents(source="PhoneDashboard", keyword="Use")
        # use_phase, use_hour = use_cleaner.clean_events(raw_event_df=raw_hour_use,
        #                                         date_col="CreatedDate",
        #                                         cleaner=CleanEventsUse(use_type="Traditional"))

        # CleanEventsUse.get_timezones(use_hour, "CreatedDatetimeHour", "CreatedEasternDatetimeHour")


    @staticmethod
    def _build_pd_status(raw_master: pd.DataFrame, alt_use_hour: pd.DataFrame):
        pd_use_puller = PullEvents(source="PhoneDashboard",
                                   keyword="Status",
                                   scratch=False,
                                   test=False,
                                   time_cols=["LastUpload"],
                                   raw_timezone="Local",
                                   appcode_col='Participant',
                                   identifying_cols=["AppCode", "Group", "Blocker",
                                                     "LastUpload", "AppVersion","PlatformVersion","PhoneModel","OptedOut"],
                                   sort_cols = ["LastUpload"],
                                   drop_cols = ['PhaseUseBrowser(ms)',
                                                'PhaseUseFB(ms)',
                                                'PhaseUseIG(ms)',
                                                'PhaseUseOverall(ms)',
                                                'PhaseUseSnap(ms)',
                                                'PhaseUseYoutube(ms)',"AsOf"],
                                   cat_cols = [],
                                   compress_type="txt",)

        raw_status = pd_use_puller.update_data()
        raw_status["LastUploadDate"] = raw_status["LastUpload"].apply(lambda x: x.date())
        use_cleaner = CleanEvents(source="PhoneDashboard", keyword="Status")
        clean_status = use_cleaner.clean_events(raw_event_df=raw_status,
                                                date_col="LastUploadDate",
                                                cleaner=CleanEventsStatus(),
                                                phase_data=False)

        pd_latest = CleanEventsStatus.get_latest_pd_health(clean_status, raw_master, alt_use_hour)
        return clean_status, pd_latest

    @staticmethod
    def _build_pd_alt(clean_trad_use_hour):
        alt_json_reader = PullEventsAlt()
        pd_alt_puller = PullEvents(source="PhoneDashboard",
                                       keyword="Alternative",
                                       scratch=False,
                                       test=False,
                                       time_cols=["Created"],
                                       raw_timezone="Local",
                                       appcode_col='AppCode',
                                       identifying_cols=["AppCode", "ForegroundApp", "CreatedDatetimeHour"],
                                       sort_cols = ["Observed","CreatedDatetimeHour"],
                                       drop_cols = ["Com.AudaciousSoftware.PhoneDashboard.AppTimeBudget", "Timezone",
                                                    "CreatedDatetime","CreatedEasternDatetime","Label", "CreatedDate",
                                                    "PlayStoreCategory","DaysObserved","Index","ZipFolder","CreatedEasternMinusLocalHours"],
                                       cat_cols = ["ForegroundApp"],
                                       compress_type="folder",
                                       processing_func=alt_json_reader.process_raw_use,
                                       file_reader=alt_json_reader.read_alt)

        # This function will read in and update all types of alternative data, will only return the use data
        # and will serialize all other data
        raw_alt_use_hour = pd_alt_puller.update_data()
        try:
            combined_raw_alt_use_hour = PullEventsAlt.combine_trad_alt(raw_alt_use_hour,clean_trad_use_hour)
        except:
            print("could not combine trad and alt")
            combined_raw_alt_use_hour = raw_alt_use_hour.copy()

        use_cleaner = CleanEvents(source="PhoneDashboard", keyword="Alternative")
        use_phase, use_hour = use_cleaner.clean_events(raw_event_df=combined_raw_alt_use_hour,
                                                       date_col="CreatedDate",
                                                       cleaner=CleanEventsUse(use_type="Alternative"))

        config_user_dict = serialize.open_yaml("config_user.yaml")
        if config_user_dict['local']['test']== False:
            try:
                print(f"\n Clean Alt Install data events {datetime.now()}")
                CleanEventsAlt.process_appcode_files(
                    input_folder = os.path.join("data", "external", "input", "PhoneDashboard", "RawAltInstall"),
                    output_file = os.path.join("data", "external", "intermediate", "PhoneDashboard", "AltInstall"),
                    cleaning_function= CleanEventsAlt.clean_install
                )
            except:
                print("could not aggregate install data")
        return use_hour, use_phase

    @staticmethod
    def _build_pd_budget():
        """processes the limit setting data"""
        pd_budget_puller = PullEvents(source="PhoneDashboard",
                                      keyword="Budget",
                                      scratch=False,
                                      test=False,
                                      time_cols=["Updated","EffectiveDate"],
                                      raw_timezone="Local",
                                      appcode_col="Source",
                                      identifying_cols=["AppCode", "App", "Updated", "EffectiveDate"],
                                      sort_cols=["Updated"],
                                      drop_cols = [],
                                      cat_cols = [],
                                      compress_type="txt")

        pd_budget = pd_budget_puller.update_data()

        budget_cleaner = CleanEvents(source="PhoneDashboard", keyword="Budget")
        clean_budget = budget_cleaner.clean_events(raw_event_df=pd_budget,
                                                    date_col="EffectiveDate",
                                                    cleaner=CleanEventsBudget(),
                                                    phase_data = False)

        budget_sum = CleanEventsBudget.get_latest_budget_data(clean_budget)

        return budget_sum, clean_budget

    @staticmethod
    def _build_pd_snooze_delay():
        """process the custom snooze data (post study functionality)"""
        pd_snooze_delay_puller = PullEvents(source="PhoneDashboard",
                                     keyword="Delays",
                                     scratch = False,
                                     test = False,
                                     time_cols=["UpdatedDatetime", "EffectiveDatetime"],
                                     raw_timezone = "Local",
                                     appcode_col="App Code",
                                     identifying_cols=["AppCode", "SnoozeDelay", "UpdatedDatetime"],
                                     sort_cols = ["UpdatedDatetime"],
                                     drop_cols= [],
                                     cat_cols = [],
                                     compress_type="txt")

        raw_delayed_snooze = pd_snooze_delay_puller.update_data()
        snooze_delay_cleaner = CleanEvents(source="PhoneDashboard", keyword="Delays")

        clean_delays = snooze_delay_cleaner.clean_events(raw_event_df=raw_delayed_snooze,
                                                   date_col= "EffectiveDate",
                                                   cleaner= CleanEventsSnoozeDelays(),
                                                   phase_data=False)

        clean_delays.to_csv(os.path.join("data","external", "intermediate", "PhoneDashboard", "Delays.csv"))



    @staticmethod
    def _build_pd_snooze():
        """processes the snooze event data"""
        pd_snooze_puller = PullEvents(source="PhoneDashboard",
                                     keyword="Snooze",
                                     scratch = False,
                                     test = False,
                                     time_cols=["Recorded", "Created"],
                                     raw_timezone = "Local",
                                     appcode_col="Source",
                                     identifying_cols=["AppCode", "App", "Event", "Created"],
                                     sort_cols = ["Created"],
                                     drop_cols= [],
                                     cat_cols = [],
                                     compress_type="txt")

        raw_snooze = pd_snooze_puller.update_data()

        snooze_cleaner = CleanEvents(source="PhoneDashboard", keyword="Snooze")

        pd_snooze = snooze_cleaner.clean_events(raw_event_df=raw_snooze,
                                                   date_col= "Date",
                                                   cleaner= CleanEventsSnooze(),
                                                   phase_data=False)

        CleanEventsSnooze.get_premature_blocks(pd_snooze)

        return pd_snooze

if __name__ == "__main__":
    pd_snooze = Builder._build_pd_snooze_delay()