WeldingSpotPerformance/src/controller/passportFormer.py

from utils.base.base import BasePointPassportFormer, BaseIdealDataBuilder
import pandas as pd



class idealDataBuilder(BaseIdealDataBuilder):
    def get_closingDF(self) -> pd.DataFrame:
        return self._get_data(self.Ts['tclose'], self.calcPhaseClose)
    
    def get_compressionDF(self) -> pd.DataFrame:
        return self._get_data(self.Ts['tgrow'], self.calcPhaseGrow)
    
    def get_openingDF(self) -> pd.DataFrame:
        return self._get_data(self.getMarkOpen(), self.calcPhaseOpen)
    
    def get_oncomingDF(self) -> pd.DataFrame:
        return self._get_data(self.Ts['tmovement'], self.calcPhaseMovement)

    def get_weldingDF(self) -> pd.DataFrame:
        data = []
        X1, X2, V1, V2, F = self.calcPhaseGrow(self.Ts['tgrow'])
        data.append({"time":0, "Position FE":X1,"Position ME":X2, "Rotor Speed FE":V1, "Rotor Speed ME":V2, "Force":F})
        data.append({"time":self.welding_time, "Position FE":X1,"Position ME":X2, "Rotor Speed FE":V1, "Rotor Speed ME":V2, "Force":F})
        return pd.DataFrame(data)
    
    def get_ideal_timings(self) -> list[float]:
        data = self.Ts
        ideal_timings = [data['tclose'], data['tgrow'], self.welding_time, self.getMarkOpen(), data['tmovement']] # TODO: add data['tmovement'], Oncoming не учитывается в производительности
        return ideal_timings
    
class PassportFormer(BasePointPassportFormer):
  
    def form_passports(self, data: list[pd.DataFrame]) -> list[list[pd.DataFrame, dict, int]]:
        return_data = [self._build_passports_pocket(dataframe) for dataframe in data]
        self._mediator.notify(self, return_data)
            

    def _build_passports_pocket(self, dataframe: pd.DataFrame) -> list[pd.DataFrame, dict, int]:
        events, point_quantity = self._filter_events(dataframe["time"], dataframe)
        if point_quantity == 0:
            return []
        
        system_settings = {key: value[0] for key, value in self._params[1].items()}
        Range = system_settings["Range ME, mm"]
        tesla_time = sum(self._params[0].get("Tesla summary time", []))
        useful_data = {"tesla_time": tesla_time, "range_ME": Range}

        points_pocket = []

        time_is_valid = not dataframe["time"].isna().all()
        
        if time_is_valid: 

            idx_shift = True if events[self._stages[-1]][0][0] == 0 else False
            
            for i in range(point_quantity):
                operator_settings = {
                    key: (value[i] if i < len(value) else value[0])
                    for key, value in self._params[0].items()
                }
                params_list = [operator_settings, system_settings]
                cache_key = self._generate_cache_key(params_list)
                if cache_key in self._ideal_data_cashe :
                    ideal_data = self._ideal_data_cashe[cache_key]
                    print(f"Cache hit")
                else:
                    ideal_data = self._build_ideal_data(idealDataBuilder=idealDataBuilder, params=params_list)
                    self._ideal_data_cashe[cache_key] = ideal_data
                    print(f"Cache miss. Computed and cached.")
                idx = i+1 if idx_shift else i
                point_timeframe = [events[self._stages[0]][0][i], events[self._stages[-1]][1][idx]]
                point_events = {key: [value[0][i], value[1][i]] for key, value in events.items()}

                points_pocket.append([point_timeframe, ideal_data, point_events])
            return dataframe, points_pocket, useful_data
            
    def update_settings(self, params: list[dict, dict]):
        self._params = params