datupapi 1.108.11__py3-none-any.whl → 1.110.0__py3-none-any.whl

datupapi/evaluate/anomaly.py

@@ -271,6 +271,9 @@ class Anomaly():
                                     if alert_anomalies_item else "")
 
         # 3. Alerta por items con poco histórico -------------------
+        items_alerta_max = np.array(items_alerta_max).astype(str)
+        items_alerta_media = np.array(items_alerta_media).astype(str)
+
         alert_insufficient_history = alerta_max > 0 or alerta_media > 0
         alert_insufficient_history_txt = (
             f"Items con menos de 24 meses en el histórico: {alerta_max}. ({', '.join(map(str, items_alerta_max))}). "
@@ -377,6 +380,7 @@ class Anomaly():
             # Aplicar LOF
             lof4.fit(item_tmp[['SuggestedForecast', 'Target']])
             probs = lof4.predict_proba(item_tmp[['SuggestedForecast', 'Target']])
+            # item_tmp["probabilidad"] = probs[:, 1]  #Agregando probabilidad de anomalía a los items
             item_tmp = item_tmp.copy()
             item_tmp.loc[:, "probabilidad"] = probs[:, 1]
             is_out4 = probs[:, 1] > (prob_lim_item_frcst/100)
@@ -450,39 +454,57 @@ class Anomaly():
         log_forecast = log_forecast.drop(columns=drop_columns)
         print(f'Logs descargados y recortados a {log_forecast.shape[0]} ejecuciones.')
 
+        if log_forecast.shape[0] < 2:
+          print('Logs insuficientes. Las alertas dependientes de logs pasarán a estado nulo')
+
         #10. Cambios en el número total de items ----------------------
-        num_actual_items = demand_item['item_id'].nunique()
-        num_ant_items = log_forecast['Items'].iloc[-2]
-        cambio_num_items = ((num_actual_items - num_ant_items) / num_ant_items) * 100
+        if log_forecast.shape[0] > 1:
+          num_actual_items = demand_item['item_id'].nunique()
+          num_ant_items = log_forecast['Items'].iloc[-2]
+          cambio_num_items = ((num_actual_items - num_ant_items) / num_ant_items) * 100
 
-        #Alerta
-        alert_items_var = True if abs(cambio_num_items) > 10 else False
-        alert_items_var_txt = f"Variación en items: {cambio_num_items:.2f}%." if alert_items_var else ""
-        print(f"El número de ítems únicos ha cambiado en un {cambio_num_items:.2f}%.")
+          #Alerta
+          alert_items_var = True if abs(cambio_num_items) > 10 else False
+          alert_items_var_txt = f"Variación en items: {cambio_num_items:.2f}%." if alert_items_var else ""
+          print(f"El número de ítems únicos ha cambiado en un {cambio_num_items:.2f}%.")
 
-        #11. Cambios en el número total de ubicaciones  -------------- DE UBICACIÓN
-        if location:
-            num_actual_loc = df_demand['location'].nunique()
-            num_ant_loc = log_forecast['Locations'].iloc[-2]
-            cambio_num_loc = ((num_actual_loc - num_ant_loc) / num_ant_loc) * 100
         else:
-            cambio_num_loc = 0
+          alert_items_var = False
+          alert_items_var_txt = 'Nulo'
 
-        #Alerta
-        alert_loc_var = True if abs(cambio_num_loc) > limite_cambio_loc else False
-        alert_loc_var_txt = f"Variación en ubicaciones: {cambio_num_loc:.2f}%." if alert_loc_var else ""
-        print(f"El número de ubicaciones únicos ha cambiado en un {cambio_num_loc:.2f}%.")
+        #11. Cambios en el número total de ubicaciones  -------------- DE UBICACIÓN
+        if log_forecast.shape[0] > 1:
+          if location:
+              num_actual_loc = df_demand['location'].nunique()
+              num_ant_loc = log_forecast['Locations'].iloc[-2]
+              cambio_num_loc = ((num_actual_loc - num_ant_loc) / num_ant_loc) * 100
+          else:
+              cambio_num_loc = 0
+
+          #Alerta
+          alert_loc_var = True if abs(cambio_num_loc) > limite_cambio_loc else False
+          alert_loc_var_txt = f"Variación en ubicaciones: {cambio_num_loc:.2f}%." if alert_loc_var else ""
+          print(f"El número de ubicaciones únicos ha cambiado en un {cambio_num_loc:.2f}%.")
+
+        else:
+          alert_loc_var = False
+          alert_loc_var_txt = 'Nulo'
 
         ##12. Aumento en el WMAPE
-        wmape_actual = log_forecast['WMAPE'].iloc[-1]
-        wmape_anterior = log_forecast['WMAPE'].iloc[-2]
+        if log_forecast.shape[0] > 1:
+          wmape_actual = log_forecast['WMAPE'].iloc[-1]
+          wmape_anterior = log_forecast['WMAPE'].iloc[-2]
 
-        #Alerta
-        alert_wmape_var = True if  wmape_anterior < wmape_actual else False
-        alert_wmape_var_txt = ((f"El error promedio aumentó de {wmape_anterior:.2f}% a {wmape_actual:.2f}%") if alert_wmape_var
-                               else (f"El error promedio disminuyó de {wmape_anterior:.2f}% a {wmape_actual:.2f}%"))
-        print(f"El error pasó de {wmape_anterior:.2f}% a {wmape_actual:.2f}%")
-        print(alert_wmape_var_txt)
+          #Alerta
+          alert_wmape_var = True if  wmape_anterior < wmape_actual else False
+          alert_wmape_var_txt = ((f"El error promedio aumentó de {wmape_anterior:.2f}% a {wmape_actual:.2f}%") if alert_wmape_var
+                                else (f"El error promedio disminuyó de {wmape_anterior:.2f}% a {wmape_actual:.2f}%"))
+          print(f"El error pasó de {wmape_anterior:.2f}% a {wmape_actual:.2f}%")
+          print(alert_wmape_var_txt)
+
+        else:
+          alert_wmape_var = False
+          alert_wmape_var_txt = 'Nulo'
 
         ##13. Fecha de corte
         fecha_corte = log_forecast['DateDataPrep'].iloc[-1]
@@ -497,7 +519,7 @@ class Anomaly():
 
         #####--------------------Creción tabla resumen
 
-        
+
         if location:
           # Creo tabla para lo items con baja precisión
           tabla = items_baja_precision[['Item', 'Location','ItemType', 'Ranking', 'AccuracyBestFit']]
@@ -516,7 +538,7 @@ class Anomaly():
           tabla = tabla.merge(historico_meses, left_on=['Item', 'Location'], right_on=['item_id', 'location'], how='left')
           tabla.drop(columns=['item_id', 'location'], inplace=True, errors='ignore')
           tabla['Historico (Meses)'] = tabla.set_index(['Item', 'Location']).index.map(df_demand.groupby(['item_id', 'location']).size())
-        
+
         else:
           # Creo tabla para lo items con baja precisión
           tabla = items_baja_precision[['Item','ItemType', 'Ranking', 'AccuracyBestFit']]
@@ -534,8 +556,15 @@ class Anomaly():
           tabla.drop(columns=['item_id'], inplace=True, errors='ignore')
           tabla['Historico (Meses)'] = tabla.set_index(['Item']).index.map(df_demand.groupby(['item_id']).size())
 
+
         #Añadir alertas LOF
+        out_if_item2['item_id'] = out_if_item2['item_id'].astype(str)
+        out_if_item4['Item'] = out_if_item4['Item'].astype(str)
+
         def obtener_alerta(item):
+
+            item = str(item)
+
             # Filtrar por item
             alerta_prep = out_if_item2[out_if_item2['item_id'] == item][['timestamp', 'probabilidad']].copy()
             alerta_forecast = out_if_item4[out_if_item4['Item'] == item][['Date', 'probabilidad']].copy()
@@ -554,6 +583,8 @@ class Anomaly():
             return alertas.to_dict(orient='records') if not alertas.empty else None
 
         tabla['AlertaAnomalia'] = tabla['Item'].apply(obtener_alerta)
+        items_con_alerta = set(out_if_item2['item_id']).union(set(out_if_item4['Item']))
+        print(f'Items con baja precisión con alertas de anomalías: {items_con_alerta}')
 
         #---------------------Cargando tabla resumen
         self.io.upload_csv(tabla, q_name='ResumenAlertas', datalake_path='output')

datupapi/inventory/src/FutureInventory/future_reorder.py

@@ -11,7 +11,7 @@ class FutureReorder():
 
     def __init__(self, df_inv, df_lead_time, df_prep, df_fcst, periods, start_date, location=False, security_stock_ref=False):
         self.df_inv = df_inv
-        self.df_lead_time = df_lead_time
+        self.df_lead_time = df_lead_time        
         self.df_prep = df_prep
         self.df_fcst = df_fcst
         self.default_coverage = 30
@@ -63,7 +63,12 @@ class FutureReorder():
         if self.location:
             metadata.append('Location')
 
-        SuggestedForecast_1p = {}
+        df_lead_time_rf = self.df_lead_time.copy()
+        df_lead_time_rf['Coverage'] = df_lead_time_rf['ReorderFreq']    
+
+        SuggestedForecast_cov = {}
+        SuggestedForecast_rf = {}
+        df_forecast = {}
         df_avg_gen = {}
         df_max_gen = {}
         df_sstock = {}
@@ -84,19 +89,40 @@ class FutureReorder():
 
             for i, date in enumerate(dates):
                 if self.location:
-                    current_df_lead_time = self.df_lead_time[(self.df_lead_time['Item'] == item) &
+                    current_df_lead_time_cov = self.df_lead_time[(self.df_lead_time['Item'] == item) &
                                                             (self.df_lead_time['Location'] == location)]
+
+                    current_df_lead_time_rf = df_lead_time_rf[(df_lead_time_rf['Item'] == item) &
+                                                            (df_lead_time_rf['Location'] == location)]
+
                     current_df_inv = self.df_inv[(self.df_inv['Item'] == item) &
                                                 (self.df_inv['Location'] == location)]
+
                 else:
-                    current_df_lead_time = self.df_lead_time[self.df_lead_time['Item'] == item]
+                    current_df_lead_time_cov = self.df_lead_time[self.df_lead_time['Item'] == item]
+                    current_df_lead_time_rf = df_lead_time_rf[df_lead_time_rf['Item'] == item]
                     current_df_inv = self.df_inv[self.df_inv['Item'] == item]
-
-                if current_df_lead_time.empty or current_df_inv.empty:
+                    
+                if current_df_lead_time_cov.empty or current_df_lead_time_rf.empty or current_df_inv.empty:                    
                     continue
 
-                # SuggestedForecast
-                SuggestedForecast_1p[i] = SuggestedForecast(df_LeadTimes=current_df_lead_time,
+                # SuggestedForecast_Coverage
+                SuggestedForecast_cov[i] = SuggestedForecast(df_LeadTimes=current_df_lead_time_cov,
+                                                            df_Forecast=self.df_fcst,
+                                                            df_Prep=self.df_prep,
+                                                            df_inv=current_df_inv,
+                                                            column_forecast='SuggestedForecast',
+                                                            columns_metadata=metadata,
+                                                            frequency_='M',
+                                                            location=self.location,
+                                                            actualdate=date,
+                                                            default_coverage_=self.default_coverage,
+                                                            join_='left').suggested_forecast()
+                
+                SuggestedForecast_cov[i].rename(columns={'SuggestedForecast':'Suggested_Coverage'},inplace=True)
+                                
+                # SuggestedForecast_ReorderFreq
+                SuggestedForecast_rf[i] = SuggestedForecast(df_LeadTimes=current_df_lead_time_rf,
                                                             df_Forecast=self.df_fcst,
                                                             df_Prep=self.df_prep,
                                                             df_inv=current_df_inv,
@@ -107,12 +133,18 @@ class FutureReorder():
                                                             actualdate=date,
                                                             default_coverage_=self.default_coverage,
                                                             join_='left').suggested_forecast()
+    
+                SuggestedForecast_rf[i].rename(columns={'SuggestedForecast':'Suggested_ReorderFreq'},inplace=True)
+                SuggestedForecast_rf[i] = SuggestedForecast_rf[i][metadata + ['Suggested_ReorderFreq']]
 
+                # Concatenar                                
+                df_forecast[i] = pd.merge(SuggestedForecast_cov[i], SuggestedForecast_rf[i], on=metadata, how='outer')                
+                
                 # Calcular AvgDailyUsage y MaxDailyUsage
                 df_avg_gen[i] = DailyUsageFuture(location=self.location,
                                                   column_forecast='SuggestedForecast',
                                                   date=date,
-                                                  df_fcst=self.df_fcst).daily_usage(SuggestedForecast_1p[i], 'AvgDailyUsage').fillna(0)
+                                                  df_fcst=self.df_fcst).daily_usage(df_forecast[i], 'AvgDailyUsage').fillna(0)
 
                 df_max_gen[i] = DailyUsageFuture(location=self.location,
                                                   column_forecast='SuggestedForecast',
@@ -121,11 +153,11 @@ class FutureReorder():
 
                 #Ajustar AvgDailyUsage y MaxDailyUsage si es cero.
                 df_avg_gen[i] = df_avg_gen[i].replace(0,0.001)
-                df_max_gen[i] = df_max_gen[i].replace(0,0.0012)
-
+                df_max_gen[i] = df_max_gen[i].replace(0,0.0012)                
+ 
                 # Calcular Stock de Seguridad
                 merge_columns = ['Item', 'Location', 'AvgLeadTime', 'MaxLeadTime'] if self.location else ['Item', 'AvgLeadTime', 'MaxLeadTime']
-                df_sstock[i] = pd.merge(df_max_gen[i], current_df_lead_time[merge_columns], on=metadata, how='inner').drop_duplicates()
+                df_sstock[i] = pd.merge(df_max_gen[i], current_df_lead_time_cov[merge_columns], on=metadata, how='inner').drop_duplicates()
 
                 # Current Period
                 if i == 0:
@@ -134,17 +166,17 @@ class FutureReorder():
                     df_inventory[i]['InventoryTransit'] = df_inventory[i]['Inventory'] + df_inventory[i]['Transit']
                     df_inventory[i] = df_inventory[i][metadata + ['InventoryTransit']]
                     df[i] = pd.merge(df_inventory[i], df_sstock[i], on=metadata, how='inner')
-
+         
                     if self.security_stock_ref:
                         df[i]['SecurityStock'] = df[i]['SecurityStockDaysRef'] * df[i]['AvgDailyUsage']
                     else:
                         df[i]['SecurityStock'] = (df[i]['MaxDailyUsage'] * df[i]['MaxLeadTime']) - (df[i]['AvgDailyUsage'] * df[i]['AvgLeadTime'])
 
-                    df[i]['ReorderPoint'] = (df[i]['SuggestedForecast'] + df[i]['SecurityStock']).clip(lower=0)
+                    df[i]['ReorderPoint'] = (df[i]['Suggested_Coverage'] + df[i]['SecurityStock']).clip(lower=0)
                     df[i]['ReorderQtyBase'] = (df[i]['ReorderPoint'] - df[i]['InventoryTransit']).clip(lower=1)
                     df[i]['ReorderQty'] = ((df[i]['ReorderQtyBase'] / df[i]['PurchaseFactor']).apply(np.ceil)) * df[i]['PurchaseFactor']
                     df[i]['ReorderQtyDays'] = (df[i]['ReorderQty'] / df[i]['AvgDailyUsage']).astype(int)
-
+                    
                 # Future Dates
                 else:
                     inventory_columns = ['Item', 'Location', 'PurchaseFactor'] if self.location else ['Item', 'PurchaseFactor']
@@ -156,15 +188,17 @@ class FutureReorder():
                     else:
                         df[i]['SecurityStock'] = (df[i]['MaxDailyUsage'] * df[i]['MaxLeadTime']) - (df[i]['AvgDailyUsage'] * df[i]['AvgLeadTime'])
 
-                    df[i]['InventoryTransit'] = ((df[i-1]['InventoryTransit'] - df[i-1]['SuggestedForecast']) + df[i-1]['ReorderQty']).clip(lower=0)
-                    df[i]['ReorderPoint'] = (df[i]['SuggestedForecast'] + df[i]['SecurityStock']).clip(lower=0)
+                    df[i]['InventoryTransit'] = ((df[i-1]['InventoryTransit'] - df[i-1]['Suggested_ReorderFreq']) + df[i-1]['ReorderQty']).clip(lower=0)
+                    df[i]['ReorderPoint'] = (df[i]['Suggested_Coverage'] + df[i]['SecurityStock']).clip(lower=0)
                     df[i]['ReorderQtyBase'] = (df[i]['ReorderPoint'] - df[i]['InventoryTransit']).clip(lower=1)
                     df[i]['ReorderQty'] = ((df[i]['ReorderQtyBase'] / df[i]['PurchaseFactor']).apply(np.ceil)) * df[i]['PurchaseFactor']
                     df[i]['ReorderQtyDays'] = (df[i]['ReorderQty'] / df[i]['AvgDailyUsage']).astype(int)
+                    
 
                 # Insert columns
                 df[i].insert(loc=0, column='Date', value=date)
                 df[i]['Item'] = item
+                
                 if self.location:
                     df[i]['Location'] = location
 
@@ -176,12 +210,12 @@ class FutureReorder():
                 df_final = pd.merge(data_frame, leadtimes, on=metadata, how='left').fillna(0)
 
                 df_final['Date'] = pd.to_datetime(df_final['Date'], format='%Y%m%d').dt.strftime('%Y-%m-%d')
-                df_final = df_final.rename(columns={'InventoryTransit': 'FutureInventory'})
-                cols_to_round = ['AvgDailyUsage', 'MaxDailyUsage', 'AvgLeadTime', 'MaxLeadTime', 'SecurityStock', 'FutureInventory', 'SuggestedForecast', 'ReorderPoint', 'ReorderQtyBase']
-                df_final[cols_to_round] = df_final[cols_to_round].round(2)
-                final_cols = ['Date', 'Item', 'ItemDescription', 'Location', 'SuggestedForecast', 'FutureInventory', 'ReorderQtyBase', 'ReorderQty', 'ReorderQtyDays', 'PurchaseFactor', 'ReorderPoint', 'SecurityStock',
+                df_final = df_final.rename(columns={'InventoryTransit': 'FutureInventory'})                
+                cols_to_round = ['SecurityStock', 'FutureInventory', 'Suggested_Coverage', 'Suggested_ReorderFreq', 'ReorderPoint', 'ReorderQtyBase']
+                df_final[cols_to_round] = df_final[cols_to_round].apply(np.ceil)
+                final_cols = ['Date', 'Item', 'ItemDescription', 'Location', 'Suggested_Coverage', 'Suggested_ReorderFreq', 'FutureInventory', 'ReorderQtyBase', 'ReorderQty', 'ReorderQtyDays', 'PurchaseFactor', 'ReorderPoint', 'SecurityStock',
                               'AvgDailyUsage', 'MaxDailyUsage', 'AvgLeadTime', 'MaxLeadTime', 'ReorderFreq', 'Coverage'] if self.location \
-                              else ['Date', 'Item', 'ItemDescription', 'SuggestedForecast', 'FutureInventory', 'ReorderQtyBase', 'ReorderQty', 'ReorderQtyDays', 'PurchaseFactor', 'ReorderPoint', 'SecurityStock',
+                              else ['Date', 'Item', 'ItemDescription', 'Suggested_Coverage', 'Suggested_ReorderFreq', 'FutureInventory', 'ReorderQtyBase', 'ReorderQty', 'ReorderQtyDays', 'PurchaseFactor', 'ReorderPoint', 'SecurityStock',
                               'AvgDailyUsage', 'MaxDailyUsage', 'AvgLeadTime', 'MaxLeadTime', 'ReorderFreq', 'Coverage']
                 df_final = df_final[final_cols]
 

{datupapi-1.108.11.dist-info → datupapi-1.110.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: datupapi
-Version: 1.108.11
+Version: 1.110.0
 Summary: Utility library to support Datup AI MLOps processes
 Author: Datup AI
 Author-email: ramiro@datup.ai

{datupapi-1.108.11.dist-info → datupapi-1.110.0.dist-info}/RECORD

@@ -7,7 +7,7 @@ datupapi/distribution/src/DistributionFunctions/functions_distribution.py,sha256
 datupapi/distribution/src/Format/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 datupapi/distribution/src/Format/distribution_format.py,sha256=CFqUHTk9StDvaOvlR3yLr3NZiFY2Ao1yVXoY-IsrNWE,3964
 datupapi/evaluate/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-datupapi/evaluate/anomaly.py,sha256=s_HJb_5T3xNhL26y5bsHWuS-ucbkhSGtCyF10d_iJ3I,32379
+datupapi/evaluate/anomaly.py,sha256=fjIDAvEPGBJdZjVXhz7Rk90WKCR5t3Hbe6zeTKVXFlw,33506
 datupapi/evaluate/errors.py,sha256=9SRYAjwRDfEdP1EnBbfA7zoQEi4xU4qI16vBE8-jkeA,7039
 datupapi/extract/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 datupapi/extract/io.py,sha256=fYPXf-SmYyw4ywbN3SjQsdl6qBQvQz1K3i9kbpiEkkA,84343
@@ -22,7 +22,7 @@ datupapi/inventory/src/Format/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5N
 datupapi/inventory/src/Format/inventory_format.py,sha256=qrHkr6orSMdiraRH69nKawW1WBi_OFbqei7z2LJeSNI,7080
 datupapi/inventory/src/FutureInventory/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 datupapi/inventory/src/FutureInventory/daily_usage_future.py,sha256=LMYL6trGdOl0piEVC-GmzwCxuWCafRhehCQDHOuP30A,3388
-datupapi/inventory/src/FutureInventory/future_reorder.py,sha256=yZtNw9B7rB6h-2T3Ywi7oQgw5hwwXT1RfK1TRDde0gU,10450
+datupapi/inventory/src/FutureInventory/future_reorder.py,sha256=SqJUiKaD7YybFO8DOQv1vBoFEhZHuP8IGFR0OXmUf0g,12776
 datupapi/inventory/src/InventoryFunctions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 datupapi/inventory/src/InventoryFunctions/functions_inventory.py,sha256=RgKlF_YTuIUs03CLGpekPqmTaRvbsvwIn-62ClWqNGg,13319
 datupapi/inventory/src/ProcessForecast/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -48,7 +48,7 @@ datupapi/transform/forecasting.py,sha256=OboiVyErzWXJAv6R4fCXiPNaoVp5dNAP9F53EDq
 datupapi/transform/ranking.py,sha256=XOI0XqMx9Cy52Xjc4LCzJCNUsJZNjgrPky7nrpELr-U,7943
 datupapi/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 datupapi/utils/utils.py,sha256=pU3mXPupm-1gvODI-kPlIpOdMHa2F9lEXvqBn6t3ajc,4637
-datupapi-1.108.11.dist-info/METADATA,sha256=s70m4oBa9C6lShSQx4C52jSSiHZDorDMtE-NCcp9JAU,1517
-datupapi-1.108.11.dist-info/WHEEL,sha256=pxyMxgL8-pra_rKaQ4drOZAegBVuX-G_4nRHjjgWbmo,91
-datupapi-1.108.11.dist-info/top_level.txt,sha256=oERwtRZu8xq2u1TDGwJwuWK0iJbH4p7x9kYECAL5So0,9
-datupapi-1.108.11.dist-info/RECORD,,
+datupapi-1.110.0.dist-info/METADATA,sha256=Ix3BdEi_gpJJv86soI-nigcTp1xE0lUFNAHuOh3FGRk,1516
+datupapi-1.110.0.dist-info/WHEEL,sha256=0CuiUZ_p9E4cD6NyLD6UG80LBXYyiSYZOKDm5lp32xk,91
+datupapi-1.110.0.dist-info/top_level.txt,sha256=oERwtRZu8xq2u1TDGwJwuWK0iJbH4p7x9kYECAL5So0,9
+datupapi-1.110.0.dist-info/RECORD,,

{datupapi-1.108.11.dist-info → datupapi-1.110.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (79.0.0)
+Generator: setuptools (80.3.1)
 Root-Is-Purelib: true
 Tag: py3-none-any