fix: prediction script

src/modules/equipment/Prediksi.py

@@ -372,7 +372,6 @@ class Prediksi:
         try:
             # Mengambil data dari database
             df = self.__fetch_data_from_db(p_equipment_id)
-
             if df is None:
                 print("Data tidak tersedia untuk prediksi.")
                 return
@@ -382,7 +381,6 @@ class Prediksi:
 
             # Tahun proyeksi
             future_years = list(range(df["year"].max() + 1, par_tahun_target + 1))
-
             # Hasil prediksi
             predictions = {"year": future_years}
 
@@ -399,10 +397,15 @@ class Prediksi:
             # Fungsi untuk prediksi menggunakan Exponential Smoothing
             def exponential_smoothing_predict(column, years):
                 data_series = df[column].fillna(0).values
+
+                # Add a small epsilon to avoid zeros in the data if needed
+                if np.any(data_series == 0):
+                    data_series = data_series + 1e-10
+
                 model = ExponentialSmoothing(
                     data_series, trend="add", seasonal=None, seasonal_periods=None
                 )
-                model_fit = model.fit()
+                model_fit = model.fit(optimized=True, use_brute=False)
                 preds = model_fit.forecast(len(years))
                 return np.abs(preds)
 

src/modules/equipment/insert_actual_data.py

@@ -21,7 +21,7 @@ async def fetch_api_data(
         # )
         try:
             response = await client.get(
-                f"{url}/main/number-of-failures/{assetnum}/{int(year)}/{int(year)}",
+                f"{url}/main/failures/{assetnum}/{int(year)}/{int(year)}",
                 timeout=30.0,
                 headers={"Authorization": f"Bearer {token}"},
             )
@@ -32,9 +32,9 @@ async def fetch_api_data(
             return {}
 
 
-def get_recursive_query(cursor, equipment_id, worktype="CM"):
+def get_recursive_query(cursor, assetnum, worktype="CM"):
     """
-    Fungsi untuk menjalankan query rekursif berdasarkan equipment_id dan worktype.
+    Fungsi untuk menjalankan query rekursif berdasarkan assetnum dan worktype.
     worktype memiliki nilai default 'CM'.
     """
     query = f"""
@@ -68,7 +68,7 @@ def get_recursive_query(cursor, equipment_id, worktype="CM"):
     ) AS tbl
     WHERE 
         tbl.worktype = '{worktype}' 
-        AND tbl.assetnum = '{equipment_id}'
+        AND tbl.assetnum = '{assetnum}'
     ORDER BY 
         tbl.assetnum, 
         tbl.year, 
@@ -114,26 +114,26 @@ async def query_data(RELIABILITY_APP_URL: str, token: str):
         # Tahun sekarang
         current_year = datetime.now().year
 
-        # Looping untuk setiap equipment_id
+        # Looping untuk setiap assetnum
         for row in results:
-            equipment_id = row["assetnum"]  # Mengambil equipment_id dari hasil query
+            assetnum = row["assetnum"]  # Mengambil assetnum dari hasil query
             forecasting_start_year = row["forecasting_start_year"] - 1
 
             # CM
             recursive_results = get_recursive_query(
-                cursor_wo, equipment_id, worktype="CM"
+                cursor_wo, assetnum, worktype="CM"
             )
             # PM
-            data_pm = get_recursive_query(cursor_wo, equipment_id, worktype="PM")
+            data_pm = get_recursive_query(cursor_wo, assetnum, worktype="PM")
             # OH
-            data_oh = get_recursive_query(cursor_wo, equipment_id, worktype="OH")
+            data_oh = get_recursive_query(cursor_wo, assetnum, worktype="OH")
             # Data Tahun
             data_tahunan = get_data_tahun(cursor)
 
             seq = 0
             # Looping untuk setiap tahun
             for year in range(forecasting_start_year, current_year + 1):
-                # print(f"Processing equipment_id {equipment_id} in year {year}")
+                # print(f"Processing assetnum {assetnum} in year {year}")
                 # Filter data berdasarkan tahun
                 recursive_row = next(
                     (r for r in recursive_results if r["year"] == year), None
@@ -151,15 +151,15 @@ async def query_data(RELIABILITY_APP_URL: str, token: str):
                 """
 
                 try:
-                    cursor.execute(check_query, (equipment_id, year))
+                    cursor.execute(check_query, (assetnum, year))
                     data_exists = cursor.fetchone()[0]
-                    # print("Data exists for equipment_id", equipment_id)
+                    # print("Data exists for assetnum", assetnum)
                 except Exception as e:
-                    print(f"Error checking data for equipment_id {equipment_id}: {e}")
+                    print(f"Error checking data for assetnum {assetnum}: {e}")
                     continue
 
                 if not data_exists:
-                    print("Data not exists for equipment_id", equipment_id)
+                    print("Data not exists for assetnum", assetnum)
                     # Insert data jika belum ada
                     if not recursive_row and not data_pm_row and not data_oh_row:
                         # Jika data recursive_row tidak ada
@@ -178,13 +178,14 @@ async def query_data(RELIABILITY_APP_URL: str, token: str):
                             )
                         """
                         api_data = await fetch_api_data(
-                            equipment_id, year, RELIABILITY_APP_URL, token
+                            assetnum, year, RELIABILITY_APP_URL, token
                         )
+                        print(api_data)
                         cursor.execute(
                             insert_query,
                             (
                                 str(uuid4()),  # id
-                                equipment_id,  # equipment_id
+                                assetnum,  # assetnum
                                 year,  # tahun
                                 seq,  # seq
                                 1,  # is_actual
@@ -215,14 +216,14 @@ async def query_data(RELIABILITY_APP_URL: str, token: str):
                                 ),
                             ),
                         )
-                        print(f"Data inserted for {equipment_id} in year {year}")
+                        print(f"Data inserted for {assetnum} in year {year}")
                     else:
-                        print("Data exists for equipment_id", equipment_id)
+                        print("Data exists for assetnum", assetnum)
                         # Jika data recursive_row ada
                         # raw_cm_interval ambil dari reliability predict
                         insert_query = """
                             INSERT INTO lcc_equipment_tr_data (
-                                id, equipment_id, tahun, seq, is_actual, 
+                                id, assetnum, tahun, seq, is_actual, 
                                 raw_cm_interval, raw_cm_material_cost, 
                                 raw_cm_labor_time, raw_cm_labor_human
                                 , raw_pm_interval, raw_pm_material_cost, raw_pm_labor_time, raw_pm_labor_human
@@ -235,17 +236,20 @@ async def query_data(RELIABILITY_APP_URL: str, token: str):
                             )
                         """
                         api_data = await fetch_api_data(
-                            equipment_id, year, RELIABILITY_APP_URL, token
+                            assetnum, year, RELIABILITY_APP_URL, token
                         )
+                        print(api_data)
                         if api_data and "data" in api_data and api_data["data"]:
                             print("API data:", api_data["data"][0]["actual_fail"])
                         else:
-                            print(f"No API data available for {equipment_id} in year {year}")
+                            print(
+                                f"No API data available for {assetnum} in year {year}"
+                            )
                         cursor.execute(
                             insert_query,
                             (
                                 str(uuid4()),  # id
-                                equipment_id,  # equipment_id
+                                assetnum,  # assetnum
                                 year,  # tahun
                                 seq,  # seq
                                 1,  # is_actual
@@ -354,7 +358,7 @@ async def query_data(RELIABILITY_APP_URL: str, token: str):
                                 ),
                             ),
                         )
-                        print(f"Data inserted for {equipment_id} in year {year}")
+                        print(f"Data inserted for {assetnum} in year {year}")
 
                 seq = seq + 1
 

src/modules/equipment/run.py

@@ -9,14 +9,28 @@ import time
 async def main(assetnum, token, RELIABILITY_APP_URL):
     start_time = time.time()
 
-    await query_data(RELIABILITY_APP_URL, token)
-    prediksi = Prediksi(RELIABILITY_APP_URL)
-    await prediksi.predict_equipment_data(
-        assetnum,
-        token=token,
-    )
-    eac = Eac()
-    eac.hitung_eac_equipment(assetnum)
+    try:
+        await query_data(RELIABILITY_APP_URL, token)
+    except Exception as e:
+        print(f"Error in query_data: {str(e)}")
+        return
+
+    try:
+        prediksi = Prediksi(RELIABILITY_APP_URL)
+        await prediksi.predict_equipment_data(
+            assetnum,
+            token=token,
+        )
+    except Exception as e:
+        print(f"Error in predict_equipment_data: {str(e)}")
+        return
+
+    try:
+        eac = Eac()
+        eac.hitung_eac_equipment(assetnum)
+    except Exception as e:
+        print(f"Error in hitung_eac_equipment: {str(e)}")
+        return
 
     end_time = time.time()
     execution_time = end_time - start_time