application

.gcloudignore

@@ -0,0 +1,19 @@
+# This file specifies files that are *not* uploaded to Google Cloud
+# using gcloud. It follows the same syntax as .gitignore, with the addition of
+# "#!include" directives (which insert the entries of the given .gitignore-style
+# file at that point).
+#
+# For more information, run:
+#   $ gcloud topic gcloudignore
+#
+.gcloudignore
+# If you would like to upload your .git directory, .gitignore file or files
+# from your .gitignore file, remove the corresponding line
+# below:
+.git
+.gitignore
+
+# Python pycache:
+__pycache__/
+# Ignored by the build system
+/setup.cfg

.streamlit/config.toml

@@ -0,0 +1,3 @@
+[theme]
+base="dark"
+font="serif"

.streamlit/secrets.toml

@@ -0,0 +1,3 @@
+[api_keys]
+identifiant = "rupture-gestion"
+password = "Carrefour123@"

App/class_input_box/input_box.py

@@ -0,0 +1,62 @@
+import pandas as pd
+import streamlit as st
+from typing import Dict
+
+
+class InputsBox:
+    def __init__(self):
+        self.data = None
+        self.columns = None
+        self.product_id = None
+        self.class_id = None
+    
+    def get_data(self):
+        uploaded_file = st.file_uploader("Choose a CSV file", type=["csv", "tsv"])
+        
+        if uploaded_file is not None:
+            try:
+                self.data = pd.read_csv(uploaded_file, dtype=str)
+            except:
+                self.data = pd.read_csv(uploaded_file, sep='\t', dtype=str)
+            
+            self.columns = self.data.columns.tolist()
+            
+            return self.data
+
+    def valid_produict_id(self) -> int:
+        min_len = st.number_input("Minimum len of product_id", max_value= 25, min_value=1, value= 2, key = "pp")
+        return min_len
+    
+    def valid_class_id(self) -> str:
+        valid = st.text_input("First element of No valid class_id separed by ;")
+        return valid.split(";")
+
+    def get_product_id(self) -> str:
+        self.product_id = st.selectbox("product_id", options=self.columns, key="product_id")
+        return self.product_id
+
+    def get_class_id(self) -> str:
+        self.class_id = st.selectbox("class_id", options=self.columns, key="class_id")
+        return self.class_id
+
+    def get_conditions(self):
+        conditions = st.multiselect(label="Conditions", options=("Number of countries", "Proportion", "Priority Countries"), key="conditions")
+        return conditions
+
+    def conditions(self):
+        col1, col2, col3 = st.columns(3)
+        conditions = {}
+
+        with col1:
+            nb_countries = st.number_input("Number of countries", min_value=1, max_value=20, value=1, key="Number of countries")
+            conditions['Number of countries'] = nb_countries
+        
+        with col2 :
+            proportion = st.number_input("Proportion", min_value=0.10, max_value=1.00, value=0.75, key="proportion")
+            conditions['Proportion'] = proportion
+
+        with col3 :
+            countries = st.checkbox("Show data with ratios ", value=True, key="show_ratio_checkbox")
+            conditions["Show data with ratios"] = countries
+
+        return conditions

App/functions_rupture/functions_gestion.py

@@ -0,0 +1,183 @@
+import numpy as np
+import pandas as pd
+import streamlit as st 
+from App.utils.priorite_pays import *
+import nltk
+nltk.download('stopwords')
+
+
+
+def valide_key(data, product_id, class_id, min_prd_id, valid_class_id):
+    data = data[data[product_id].str.len() > min_prd_id]
+    try :
+        data = data[~data[class_id].str[0].isin(valid_class_id)]
+    except :
+        pass
+    return data
+
+
+def calcul_total_par_ligne(data, produit_id, class_id):
+
+    matrice = pd.crosstab(data[produit_id], data[class_id])
+    total_by_ligne = matrice.sum(axis = 1)
+
+    plus_k_2 = list(total_by_ligne[total_by_ligne.apply(lambda x : x > 1)].index)
+    df = data[data[produit_id].isin(plus_k_2)]
+    matrice = pd.crosstab(df[produit_id], df[class_id])
+
+    total_by_ligne = matrice.sum(axis = 1)
+    total_by_line = pd.DataFrame({produit_id : total_by_ligne.index , "total_by_ligne": total_by_ligne.values})
+
+    return total_by_line, matrice
+
+
+@st.cache_data
+def matrice_creuse(matrice, produit_id, class_id):
+    stacked = matrice.stack()
+    non_zero = stacked[stacked != 0]
+    ligne = non_zero.index.get_level_values(0).astype(str).tolist()
+    colonne = non_zero.index.get_level_values(1).astype(str).tolist()
+    valeur = non_zero.values.tolist()
+    sparse_matrix = pd.DataFrame({produit_id : ligne, class_id : colonne, "nombre": valeur})            
+    return sparse_matrix
+
+
+@st.cache_data
+def nouvelle_data( data, produit_id, class_id):
+
+    total_by_line, matrice = calcul_total_par_ligne(data, produit_id, class_id)
+    sparse_matrix = matrice_creuse( matrice, produit_id,class_id)
+    Data = pd.merge(sparse_matrix, total_by_line, on =[produit_id])
+    Data["Proportion"] = Data.nombre / Data.total_by_ligne
+    merged = Data.merge(data, left_on=[class_id, produit_id], right_on=[class_id, produit_id])
+    try :
+       Country = merged.groupby([class_id, produit_id])['Country'].agg(lambda x: x.tolist())
+    except :
+       try :
+           Country = merged.groupby([class_id, produit_id])['COUNTRY_KEY'].agg(lambda x: x.tolist())
+       except :
+           try :
+               Country = merged.groupby([class_id, produit_id])['COUNTRY'].agg(lambda x: x.tolist())
+           except :
+               pass
+    return Country, merged        
+
+
+def country(produit_id, class_id, Country):
+    return Country[produit_id, class_id]
+
+
+def finale_merged(merged, Country, produit_id, class_id):
+    merged_finale = None
+    try:
+        merged["Countries"] = merged.apply(lambda row: country(row[1], row[0], Country), axis=1)
+        merged['Countries'] = merged['Countries'].apply(tuple)
+        merged_finale = merged.drop_duplicates(subset=[produit_id, class_id, 'Countries'])
+    except Exception as e:
+        st.warning(f"Une erreur s'est produite : {e}")
+    finally:
+        return merged_finale
+
+
+def cond_pays_proportion(merged_finale, nb_pays, proportion, produit_id):
+
+    data = merged_finale[((merged_finale.Proportion >= proportion) & (merged_finale.total_by_ligne >= nb_pays))]
+    cles = data[produit_id].unique()
+    df = merged_finale[merged_finale[produit_id].isin(cles)]
+    return df
+
+
+def cond_pays_priorite(merged_finale, produit_id):
+
+    data = merged_finale[((merged_finale.Proportion == 0.5) & (merged_finale.total_by_ligne >= 2))]
+    cles = data[produit_id].unique()
+    df = merged_finale[merged_finale[produit_id].isin(cles)]
+
+    df.loc[:, "Poids"] = df["Countries"].apply(lambda x : np.sum([dico[y] for y in x]))
+
+    duplicated_subclass = df.duplicated(subset=[produit_id, "Poids"], keep=False)
+    df_equa = df[duplicated_subclass]
+
+    df_nequa = df[~df.isin(df_equa)].dropna()
+
+    return df, df_equa, df_nequa
+
+
+
+import pandas as pd
+
+def data_1_1(df_nequa, produit_id, class_id):
+    #st.write(f'{class_id[:-4]}_DESC_FR')
+    df_nequa_2 = df_nequa[(df_nequa.Countries.apply(lambda x: len(x) > 1))]
+    max_poids_index = df_nequa_2.groupby(produit_id)['Poids'].idxmax()
+
+    for barcode in df_nequa_2[produit_id].unique().tolist():
+      df_nequa_2.loc[df_nequa_2[produit_id] == barcode, class_id]= df_nequa_2.loc[max_poids_index[barcode],class_id]
+      df_nequa_2.loc[df_nequa_2[produit_id] == barcode, f'{class_id[:-4]}_DESC_FR']= df_nequa_2.loc[max_poids_index[barcode],f'{class_id[:-4]}_DESC_FR']
+
+    df_duplicate = df_nequa_2.copy()
+    df_duplicate.Countries = df_duplicate.Countries.apply(lambda x : ','.join(x))
+    new_rows = []
+    for index, row in df_duplicate.iterrows():
+        countries = row['Countries'].split(',')
+        for country in countries:
+            new_row = row.copy()
+            new_row['Countries'] = country
+            new_rows.append(new_row)
+
+    new_df = pd.DataFrame(new_rows)
+    new_df = new_df.drop_duplicates()
+    try :
+        new_df = new_df.rename(columns={'Countries': 'Country'})
+    except :
+        pass
+
+    return new_df
+
+
+
+
+def finale_merge(data, new_data, produit_id, class_id):
+
+    merged_df = pd.merge(data, new_data, on=["COUNTRY_KEY", produit_id], how="left", suffixes=("", "_y"))
+    merged_df[class_id] = merged_df[f"{class_id}_y"].fillna(merged_df[class_id])
+    merged_df[f"{class_id[:-4]}_DESC_FR"] = merged_df[f"{class_id[:-4]}_DESC_FR_y"].fillna(merged_df[f"{class_id[:-4]}_DESC_FR"])
+   
+    df_finale = merged_df[[produit_id, "COUNTRY_KEY",	class_id,	f"{class_id[:-4]}_DESC_FR"]]
+
+    merged = pd.merge(data, df_finale, how='outer',  indicator=True)
+
+    data_finale = merged[merged['_merge'] != 'both']
+
+    data_finale = data_finale.rename(columns={'_merge': 'Changements'})
+
+    data_finale.sort_values(by =[produit_id], ascending=True, inplace =True)
+
+    data_finale["Changements"] = data_finale["Changements"].apply(lambda x : "Avant" if x == "left_only" else "Après")
+
+    data_finale = data_finale[[produit_id, "COUNTRY_KEY",	class_id,	f"{class_id[:-4]}_DESC_FR", "Changements"]]
+    data_finale.drop_duplicates(inplace=True)
+
+    return  data_finale, df_finale
+
+
+
+def data_1_FR(df, produit_id, class_id):
+    
+    df_f_f = df[df.Country == "FRA"]
+
+    barcodes = df_f_f[produit_id].unique()
+    max = 0
+    Barcodes = []
+    for barcode in barcodes:
+        items = df_f_f.item_key[df_f_f[produit_id] == barcode].tolist()
+        if len(items) == 2:
+          Barcodes.append(barcode)
+          if "R" in items[0]:
+              df_f_f.loc[(df_f_f[produit_id] == barcode) & (df_f_f.item_key == items[0]), class_id] = df_f_f.loc[(df_f_f[produit_id] == barcode) & (df_f_f.item_key == items[1]), class_id].values
+              df_f_f.loc[(df_f_f[produit_id] == barcode) & (df_f_f.item_key == items[0]), f'{class_id[:-3]}_DESC_FR'] = df_f_f.loc[(df_f_f[produit_id] == barcode) & (df_f_f.item_key == items[1]), f'{class_id[:-3]}_DESC_FR'].values
+
+          if "R" in items[1]:
+              df_f_f.loc[(df_f_f[produit_id] == barcode) & (df_f_f.item_key == items[1]), class_id] = df_f_f.loc[(df_f_f[produit_id] == barcode) & (df_f_f.item_key == items[0]), class_id].values
+              df_f_f.loc[(df_f_f[produit_id] == barcode) & (df_f_f.item_key == items[1]), f'{class_id[:-3]}_DESC_FR'] = df_f_f.loc[(df_f_f[produit_id] == barcode) & (df_f_f.item_key == items[0]), f'{class_id[:-3]}_DESC_FR'].values
+    return df_f_f

App/utils/divers_function.py

@@ -0,0 +1,39 @@
+import streamlit as st
+import pandas as pd
+
+@st.cache_data
+def convert_df(df):
+    return df.to_csv().encode('utf-8')
+
+@st.cache_data
+def supprime_country(df):
+    try :
+       df.drop(["Country"], axis = 1, inplace = True)
+    except :
+       try :
+           df.drop(["COUNTRY_KEY"], axis = 1, inplace = True)
+       except :
+           try :
+               df.drop(["COUNTRY"],  axis = 1, inplace = True)
+           except :
+               pass
+    return df
+
+
+
+
+def Merger(df, data_tr, produit_id, class_id):
+    keys = data_tr[produit_id].unique()
+    df_finale_v1 = df[df[produit_id].isin(keys)]
+
+    df_finale_v1.loc[:,f'old_{class_id}'] = df_finale_v1.loc[:,class_id]
+
+    merged_df = pd.merge(df_finale_v1, data_tr, on=[produit_id], how='inner',  indicator=True)
+
+    merged_df[class_id] = merged_df[f'{class_id}_x'].fillna(merged_df[f'old_{class_id}'])
+    
+    # Filtrer les lignes où 'class_id' a été modifié
+    merged_df = merged_df[merged_df[f'old_{class_id}'] != merged_df[f'{class_id}_y']]
+    finale_df = merged_df[["COUNTRY_KEY", "ITEM_DESC_x",f"old_{class_id}",f'{class_id[:-4]}_DESC_FR_x', f'{class_id}_y',  f'{class_id[:-4]}_DESC_FR_y',"ITEM_DESC_y","nombre","total_by_ligne", "Proportion", "Countries"]]
+    return finale_df
+

App/utils/login.py

@@ -0,0 +1,163 @@
+import streamlit as st
+import bcrypt
+import streamlit as st 
+import pandas as pd 
+from App.class_input_box.input_box import *
+from App.functions_rupture.functions_gestion import *
+from App.utils.divers_function import *
+from App.utils.login import *
+
+from streamlit_extras.chart_container import chart_container
+
+
+def hash_password(password):
+    salt = bcrypt.gensalt()
+    hashed_password = bcrypt.hashpw(password.encode('utf-8'), salt)
+    return hashed_password
+
+def validate_login(email, password):
+    state = SessionState.get(is_authenticated=False)
+    stored_email = "rupture-gestion"  # Example stored email
+    stored_password =hash_password("Carrefour123!")  # Example hashed password
+    
+    if email == stored_email and bcrypt.checkpw(password.encode('utf-8'), stored_password):
+        state.is_authenticated = True
+    
+    return state.is_authenticated
+
+def login_page(state):
+
+    email = st.text_input("Email")
+    password = st.text_input("Password",type="password") 
+
+    check_password = st.button('Login')
+
+    if check_password:
+        return validate_login(email,password)
+    return state.is_authenticated
+
+
+@st.cache(suppress_st_warning=True, allow_output_mutation=True)
+def main_() :
+
+    email, password, login = login_page()
+    
+    if login:
+        if validate_login(email, password):
+            st.sidebar.success("Login successful!")
+
+            st.title("Gestion des ruptures ")
+
+            input_box = InputsBox()
+            data = input_box.get_data()
+
+            try:
+                if data.shape[0] != 0 :
+                    st.header("Data")
+
+                    st.dataframe(data)
+
+                    "## Filters"
+
+                    col1, col2 = st.columns(2)
+
+                    with col1 :
+                        product_id = input_box.get_product_id()
+
+                    with col2 :
+                        class_id = input_box.get_class_id()
+
+                    col1, col2 = st.columns(2)
+
+                    with col1 :
+                        min_product_id = input_box.valid_produict_id()
+
+                    with col2 :
+                        vaind_class_id = input_box.valid_class_id()
+
+                    conditions = input_box.conditions()
+
+                    if st.button("RUN ", key="run_button"):
+                        data = valide_key(data, product_id, class_id, min_product_id, vaind_class_id )
+                        Country, merged = nouvelle_data(data, 
+                                                        str(product_id), 
+                                                        str(class_id))
+
+                        merged_final = finale_merged(merged, 
+                                                     Country, 
+                                                     product_id, 
+                                                     class_id)            
+
+                        if conditions["Show data with ratios"]:
+                            st.subheader("Show data with ratios")
+                            st.dataframe(merged_final)
+
+                            csv = convert_df(merged_final)
+                            st.download_button(label="Download data as CSV",
+                                               data=csv,
+                                               file_name='sample_df.csv',
+                                               mime='text/csv',)
+
+                        data_countries_ratio = cond_pays_proportion(merged_final, 
+                                                                    conditions["Number of countries"], 
+                                                                    conditions["Proportion"], 
+                                                                    product_id)
+
+                        df = supprime_country(data_countries_ratio)
+                        csv = convert_df(df)
+
+                        """## The data below is filtered as follows: """
+                        "- Number of countries greater than or equal to ", conditions["Number of countries"]
+                        "- The proportion with the highest ", class_id ," is greater than or equal to ",conditions["Proportion"]
+
+                        finale_df = Merger(data,
+                                           df, 
+                                           product_id, 
+                                           class_id)
+
+                        tab1, tab2 = st.tabs(["Data without decision-making", "Data with proposed changes"])
+
+                        with tab1 :
+                            st.subheader("Data without decision-making")
+                            st.dataframe(df)
+                            st.download_button(label="Download data as CSV",
+                                               data=csv,
+                                               file_name='sample_df.csv',
+                                               mime='text/csv',)
+
+                        with tab2 :
+                            st.subheader("Data with proposed changes")
+                            st.dataframe(finale_df)
+                            csv_f = convert_df(finale_df)
+                            st.download_button(label="Download data as CSV",
+                                                   data=csv_f,
+                                                   file_name='sample_df.csv',
+                                                   mime='text/csv',)
+
+                        "## Country priority "
+
+                        priority_data = cond_pays_priorite(merged_final, product_id)
+
+                        tab1, tab2 = st.tabs(["Data without decision-making", "Data with proposed changes"])
+
+                        with tab1 :
+                            st.subheader("Data without decision-making")
+                            st.dataframe(priority_data)
+                            csv_f = convert_df(priority_data)
+                            st.download_button(label="Download data as CSV",
+                                                   data=csv_f,
+                                                   file_name='sample_df.csv',
+                                                   mime='text/csv',)
+
+                        with tab2 :
+                            "to do"
+
+            except:
+                pass
+                st.write("An error occured. Please check your inputs.")
+
+        else:
+            st.error("Identifiant ou mot de passe incorrect !")
+
+if __name__ == "__main__":
+    main_()

App/utils/priorite_pays.py

@@ -0,0 +1,10 @@
+
+
+pays_all = ["FRA", "BEL" ,"ESP","ITA", "BRA","ATA","ARG", "POL", "ROU", "BIG","SAM", 
+           "UAE","SAU","KWT","OMN","BHR","QAT","JOR","EGY","ARM","UZB","IRN","KEN","GEO","LEB","UGA","PAK","IRQ",
+           "MTQ","GLP","REU","GUA","MTS","GLS","GUF","MTA","GLA","GUS","SXM","DOM",
+           "MAR","AMA","TUN","DZA","TUR","IAP","IET","TWN"]
+
+dico = {}
+for i in pays_all:
+  dico[i] = len(pays_all) - pays_all.index(i)

Dockerfile

@@ -0,0 +1,17 @@
+FROM python:3.11
+
+# Expose port you want your app on
+EXPOSE 8080
+
+# Upgrade pip and install requirements
+COPY requirements.txt requirements.txt
+RUN pip install -U pip
+RUN pip install -r requirements.txt
+
+# Copy app code and set working directory
+COPY . ./
+
+WORKDIR /rupture
+
+# Run
+ENTRYPOINT ["streamlit", "run", "main.py", "–server.port=8080", "–server.address=0.0.0.0"]

LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

RUPTURE.egg-info/PKG-INFO

@@ -0,0 +1,4 @@
+Metadata-Version: 2.1
+Name: RUPTURE
+Version: 0.0.0
+License-File: LICENSE

RUPTURE.egg-info/SOURCES.txt

@@ -0,0 +1,7 @@
+LICENSE
+README.md
+setup.py
+RUPTURE.egg-info/PKG-INFO
+RUPTURE.egg-info/SOURCES.txt
+RUPTURE.egg-info/dependency_links.txt
+RUPTURE.egg-info/top_level.txt

RUPTURE.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

RUPTURE.egg-info/top_level.txt

@@ -0,0 +1 @@
+

app.yaml

@@ -0,0 +1,2 @@
+runtime: python310
+service: default

essaie.py

@@ -0,0 +1,195 @@
+import streamlit as st 
+import pandas as pd 
+import time
+from App.class_input_box.input_box import *
+from App.functions_rupture.functions_gestion import *
+from App.utils.divers_function import *
+from App.utils.login import *
+
+
+def app():
+        st.title("Gestion des ruptures ")
+
+        input_box = InputsBox()
+        
+        data = input_box.get_data()
+
+        try:
+            if data.shape[0] != 0 :
+                st.header("Data")
+
+                st.dataframe(data)
+
+                "## Parameters"
+
+                col1, col2 = st.columns(2)
+
+                with col1 :
+                    product_id = input_box.get_product_id()
+
+                with col2 :
+                    class_id = input_box.get_class_id()
+
+                '## Filters'
+                col1, col2 = st.columns(2)
+                
+                with col1 :
+                    min_product_id = input_box.valid_produict_id()
+
+                with col2 :
+                    vaind_class_id = input_box.valid_class_id()
+
+                conditions = input_box.conditions()
+
+                if st.button("RUN ", key="run_button"):
+                    data = valide_key(data, product_id, class_id, min_product_id, vaind_class_id )
+                    Country, merged = nouvelle_data(data, 
+                                                    str(product_id), 
+                                                    str(class_id))
+
+                    merged_final = finale_merged(merged, 
+                                                 Country, 
+                                                 product_id, 
+                                                 class_id)            
+
+                    if conditions["Show data with ratios"]:
+                        st.subheader("Show data with ratios")
+                        merged_final.loc[:, "Evaluation"]= True
+                        merged_final  = st.data_editor(merged_final)
+                        #st.dataframe(merged_final)
+
+                        csv = convert_df(merged_final)
+                        st.download_button(label="Download data as CSV",
+                                           data=csv,
+                                           file_name='sample_df.csv',
+                                           mime='text/csv',)
+
+                    data_countries_ratio = cond_pays_proportion(merged_final, 
+                                                                conditions["Number of countries"], 
+                                                                conditions["Proportion"], 
+                                                                product_id)
+
+                    df = supprime_country(data_countries_ratio)
+                    csv = convert_df(df)
+
+                    """## The data below is filtered as follows: """
+                    "- Number of countries greater than or equal to ", conditions["Number of countries"]
+                    "- The proportion with the highest ", class_id ," is greater than or equal to ",conditions["Proportion"]
+
+                    DF = df[((df.Proportion >= conditions["Proportion"]) & (df.total_by_ligne >= conditions["Number of countries"]))]
+
+                    finale_df = Merger(data,
+                                       DF,
+                                       product_id, 
+                                       class_id)
+
+                    tab1, tab2 = st.tabs(["Data without decision-making", "Data with proposed changes"])
+
+                    with tab1 :
+                        st.subheader("Data without decision-making")
+                        df.loc[:, "Evaluation"] = True
+                        df = st.data_editor(df)
+                        #st.dataframe(df)
+                        st.download_button(label="Download data as CSV",
+                                           data=csv,
+                                           file_name='sample_df.csv',
+                                           mime='text/csv',)
+
+                    with tab2 :
+                        st.subheader("Data with proposed changes")
+                        finale_df.loc[:, "Evaluation"] = True
+                        finale_df = st.data_editor(finale_df)
+                        #st.dataframe(finale_df)
+                        csv_f = convert_df(finale_df)
+                        st.download_button(label="Download data as CSV",
+                                               data=csv_f,
+                                               file_name='sample_df.csv',
+                                               mime='text/csv',)
+
+                    "## Country priority "
+
+                    priority_data, df_equa, df_nequa = cond_pays_priorite(merged_final, product_id)
+                    tab1, tab2, tab3, tab4 = st.tabs(["Data without decision-making", "Equality case and mt1", "Cases of inequality", "Data with proposed changes mt2"])
+
+                    with tab1 :
+                        st.subheader("Data without decision-making")
+                        priority_data.loc[:, "Evaluation"] = True
+                        priority_data = st.data_editor(priority_data)
+                        #st.dataframe(priority_data)
+                        csv_f = convert_df(priority_data)
+                        st.download_button(label="Download data as CSV",
+                                               data=csv_f,
+                                               file_name='sample_df.csv',
+                                               mime='text/csv',)
+
+                    with tab2 :
+                        st.subheader("Equality case")
+                        df_equa.loc[:, "Evaluation"]= True
+                        df_equa = st.data_editor(df_equa)
+                        #st.dataframe(df_equa)
+                        csv_f = convert_df(df_equa)
+                        st.download_button(label="Download data as CSV",
+                                               data=csv_f,
+                                               file_name='sample_df.csv',
+                                               mime='text/csv',)
+
+                    with tab3 :
+                        st.subheader("Cases of inequality")
+                        df_nequa_ = df_nequa[(df_nequa.total_by_ligne.apply(lambda x: int(x) > 2))]
+                        df_nequa_.loc[:, "Evaluation"]= True
+                        df_nequa_ = st.data_editor(df_nequa_)
+                        
+                        csv_f = convert_df(df_nequa_)
+                        st.download_button(label="Download data as CSV",
+                                               data=csv_f,
+                                               file_name='sample_df.csv',
+                                               mime='text/csv',)
+                        
+
+                    #df_finale= data_1_1(priority_data, product_id, class_id)  
+                    max_poids_index = df_nequa_.groupby('BARCODE')['Poids'].idxmax()
+
+                    # Récupérer les lignes correspondantes
+                    df_max_poids = df_nequa_.loc[max_poids_index]
+                    df_max_poids.drop(["COUNTRY_KEY"], axis = 1, inplace= True)
+                    finale_df_  =  Merger(data,df_max_poids,  product_id, class_id)   #, _ = finale_merge(data, df_finale, product_id, class_id)  
+                    with tab4 :
+                        st.subheader("Cases of inequality")
+                        finale_df_.loc[:, "Evaluation"]= True
+                        finale_df_ = st.data_editor(finale_df_)
+                        
+                        csv_f = convert_df(finale_df_)
+                        st.download_button(label="Download data as CSV",
+                                               data=csv_f,
+                                               file_name='sample_df.csv',
+                                               mime='text/csv',)
+
+                    st.subheader(" One vs One with similarity score")
+                    df_nequa_1 = df_nequa[(df_nequa.total_by_ligne.apply(lambda x: int(x) == 2))]
+
+                    max_poids_index1 = df_nequa_1.groupby('BARCODE')['Poids'].idxmax()
+
+                    # Récupérer les lignes correspondantes
+                    df_max_poids1 = df_nequa_1.loc[max_poids_index1]
+                    df_max_poids1.drop(["COUNTRY_KEY"], axis = 1, inplace= True)
+                    finale_df_1  =  Merger(data,df_max_poids1,  product_id, class_id)
+                    finale_df_1.loc[:, "Evaluation"]= True
+                    finale_df_1 = st.data_editor(finale_df_1)
+
+                    st.success('Done!', icon="✅")
+                    st.balloons()
+
+        except:
+            pass
+            st.error('This is an error', icon="🚨")
+            st.info('Ensure that column names are capitalized and that product_id and class_id descriptions are present, as well as a country column.', icon="ℹ️")
+
+
+if __name__ == "__main__":
+
+    st.toast("Je t'aime Kadi Jolie ")
+    time.sleep(.5)
+    st.toast('I love you Kadi my wife')
+    time.sleep(.5)
+    st.toast('Holà!', icon='🎉')
+    app()

main.py

@@ -0,0 +1,119 @@
+import streamlit as st 
+import pandas as pd 
+from App.class_input_box.input_box import *
+from App.functions_rupture.functions_gestion import *
+from App.utils.divers_function import *
+from App.utils.login import *
+
+from streamlit_extras.chart_container import chart_container
+
+
+st.title("Gestion des ruptures ")
+
+input_box = InputsBox()
+data = input_box.get_data()
+
+try:
+    if data.shape[0] != 0 :
+        st.header("Data")
+
+        st.dataframe(data)
+
+        "## Filters"
+
+        col1, col2 = st.columns(2)
+
+        with col1 :
+            product_id = input_box.get_product_id()
+
+        with col2 :
+            class_id = input_box.get_class_id()
+
+        col1, col2 = st.columns(2)
+
+        with col1 :
+            min_product_id = input_box.valid_produict_id()
+
+        with col2 :
+            vaind_class_id = input_box.valid_class_id()
+
+        conditions = input_box.conditions()
+
+        if st.button("RUN ", key="run_button"):
+            data = valide_key(data, product_id, class_id, min_product_id, vaind_class_id )
+            Country, merged = nouvelle_data(data, 
+                                            str(product_id), 
+                                            str(class_id))
+
+            merged_final = finale_merged(merged, 
+                                         Country, 
+                                         product_id, 
+                                         class_id)            
+
+            if conditions["Show data with ratios"]:
+                st.subheader("Show data with ratios")
+                st.dataframe(merged_final)
+
+                csv = convert_df(merged_final)
+                st.download_button(label="Download data as CSV",
+                                   data=csv,
+                                   file_name='sample_df.csv',
+                                   mime='text/csv',)
+
+            data_countries_ratio = cond_pays_proportion(merged_final, 
+                                                        conditions["Number of countries"], 
+                                                        conditions["Proportion"], 
+                                                        product_id)
+
+            df = supprime_country(data_countries_ratio)
+            csv = convert_df(df)
+
+            """## The data below is filtered as follows: """
+            "- Number of countries greater than or equal to ", conditions["Number of countries"]
+            "- The proportion with the highest ", class_id ," is greater than or equal to ",conditions["Proportion"]
+
+            finale_df = Merger(data,
+                               df, 
+                               product_id, 
+                               class_id)
+            
+            tab1, tab2 = st.tabs(["Data without decision-making", "Data with proposed changes"])
+            
+            with tab1 :
+                st.subheader("Data without decision-making")
+                st.dataframe(df)
+                st.download_button(label="Download data as CSV",
+                                   data=csv,
+                                   file_name='sample_df.csv',
+                                   mime='text/csv',)
+            
+            with tab2 :
+                st.subheader("Data with proposed changes")
+                st.dataframe(finale_df)
+                csv_f = convert_df(finale_df)
+                st.download_button(label="Download data as CSV",
+                                       data=csv_f,
+                                       file_name='sample_df.csv',
+                                       mime='text/csv',)
+                
+            "## Country priority "
+
+            priority_data = cond_pays_priorite(merged_final, product_id)
+
+            tab1, tab2 = st.tabs(["Data without decision-making", "Data with proposed changes"])
+
+            with tab1 :
+                st.subheader("Data without decision-making")
+                st.dataframe(priority_data)
+                csv_f = convert_df(priority_data)
+                st.download_button(label="Download data as CSV",
+                                       data=csv_f,
+                                       file_name='sample_df.csv',
+                                       mime='text/csv',)
+                
+            with tab2 :
+                "to do"
+
+except:
+    pass
+    st.write("An error occured. Please check your inputs.")

query

@@ -0,0 +1 @@
+docker

requirements.txt

@@ -0,0 +1,8 @@
+numpy==1.23.4
+pandas==1.3.4
+setuptools==65.6.3
+streamlit==1.25.0
+streamlit_extras==0.3.0
+gunicorn
+nltk
+bcrypt

rupture

@@ -0,0 +1 @@
+Subproject commit a552d499acb5c1c855daf3e23e8d3582ec467f09

setup.py

@@ -0,0 +1,3 @@
+from setuptools import setup, find_packages
+
+setup(name="RUPTURE", packages=find_packages())

start

@@ -0,0 +1 @@
+docker

stop

@@ -0,0 +1 @@
+docker