datupapi 1.109.0__tar.gz → 1.110.1__tar.gz

{datupapi-1.109.0 → datupapi-1.110.1}/PKG-INFO

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

{datupapi-1.109.0 → datupapi-1.110.1}/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.109.0 → datupapi-1.110.1}/datupapi.egg-info/PKG-INFO

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

{datupapi-1.109.0 → datupapi-1.110.1}/setup.py

@@ -1,7 +1,7 @@
 from setuptools import setup, find_packages
 
 setup(name='datupapi',
-      version='1.109.0',
+      version='1.110.1',
       description='Utility library to support Datup AI MLOps processes',
       long_description_content_type="text/markdown",
       long_description="foo bar baz",