Spaces:
Sleeping
Sleeping
| import base64 | |
| import streamlit as st | |
| import pandas as pd | |
| from pg_utils_fn import create_entity_name_list, fetch_block_mapping, fetch_gp_mapping | |
| from pg_utils_fn import fetch_district_mapping | |
| from pg_utils_fn import populate_entity_mapping | |
| from pg_utils_fn import load_file | |
| from utils import update_all_data | |
| from pg_utils_fn import create_village_mapped_dataset, populate_village_mapping, process_file | |
| from pg_utils_fn import create_sub_district_mapped_dataset, populate_sub_district_mapping | |
| from pg_utils_fn import create_gp_mapped_dataset, populate_gp_mapping | |
| from pg_utils_fn import create_block_mapped_dataset, populate_block_mapping | |
| from pg_utils_fn import generate_download_link | |
| from pg_utils_fn import update_variations | |
| from pg_utils_fn import create_district_mapped_dataset | |
| from pg_utils_fn import create_mapped_dataset, get_state_mappings | |
| from databasefn import insert_record | |
| # Set Streamlit configuration | |
| st.set_option('deprecation.showfileUploaderEncoding', False) | |
| def home_page(): | |
| # Add an attractive header | |
| st.title('CodeYatra') | |
| #st.image('mandala.jpg') # Replace 'your_logo.png' with the path to your logo image | |
| # Write a brief and engaging introduction | |
| st.write( | |
| "Welcome to the CodeYatra LGD Mapping App! 🌟 This app makes mapping a breeze, allowing " | |
| "you to explore states, districts, sub-districts, blocks, gram panchayats, and villages LGD Mapping with ease. " | |
| "Whether you're a researcher 👩🔬, a data analyst 📊, or simply curious about India's geography, this app is " | |
| "the perfect resource for you. Say goodbye to tedious manual searches and say hello to accurate and " | |
| "up-to-date mapping at your fingertips. Let's embark on an exciting journey of exploration and " | |
| "discovery with the CodeYatra LGD Code Mapping App! 🗺️🚀" | |
| ) | |
| st.warning("⚠️ **Important Notice:** ") | |
| st.write(" To ensure smooth operation of the application, please update the column names as follows:") | |
| st.write("- State: Change the state column name to 'state_name'") | |
| st.write("- District: Change the district column name to 'district_name'") | |
| st.write("- Sub District: Change the sub district column name to 'sub_district_name'") | |
| st.write("- Block: Change the block column name to 'block_name'") | |
| st.write("- Gram Panchayat (GP): Change the gp column name to 'gp_name'") | |
| st.write("- Village: Change the village column name to 'village_name'") | |
| # Add visually appealing images or illustrations to showcase the app's features | |
| #st.image('your_app_features.png', use_column_width=True) # Replace 'your_app_features.png' with the path to your app features image | |
| st.subheader('Start Mapping Now') | |
| st.write('Ready to explore and map LGD codes? Click the button below to get started.') | |
| if st.button('Start Mapping', key='sub_mapping_button'): | |
| #redirect_to_subset_dataset_page() | |
| redirect_to_state_mapping_page() | |
| def redirect_to_update_dataset_page(): | |
| # Modify the URL parameters to navigate to the state mapping page | |
| state_mapping_url = st.experimental_set_query_params(page='update') | |
| page_route() | |
| st.experimental_rerun() | |
| def redirect_to_subset_dataset_page(): | |
| # Modify the URL parameters to navigate to the state mapping page | |
| state_mapping_url = st.experimental_set_query_params(page='subset') | |
| page_route() | |
| st.experimental_rerun() | |
| def redirect_to_state_mapping_page(): | |
| # Modify the URL parameters to navigate to the state mapping page | |
| state_mapping_url = st.experimental_set_query_params(page='state') | |
| page_route() | |
| st.experimental_rerun() | |
| def redirect_to_district_page(): | |
| # Modify the URL parameters to navigate to the district page | |
| district_url = st.experimental_set_query_params(page='district') | |
| page_route() | |
| st.experimental_rerun() | |
| def redirect_to_block_page(): | |
| # Modify the URL parameters to navigate to the block page | |
| block_url = st.experimental_set_query_params(page='block') | |
| page_route() | |
| st.experimental_rerun() | |
| def redirect_to_panchayat_page(): | |
| # Modify the URL parameters to navigate to the block page | |
| panchayat_url = st.experimental_set_query_params(page='panchayat') | |
| page_route() | |
| st.experimental_rerun() | |
| def redirect_to_village_page(): | |
| # Modify the URL parameters to navigate to the block page | |
| panchayat_url = st.experimental_set_query_params(page='village') | |
| page_route() | |
| st.experimental_rerun() | |
| def redirect_to_sub_district_page(): | |
| # Modify the URL parameters to navigate to the district page | |
| subdistrict_url = st.experimental_set_query_params(page='subdistrict') | |
| page_route() | |
| st.experimental_rerun() | |
| def page_route(): | |
| query_params = st.experimental_get_query_params() | |
| if "page" in query_params and query_params["page"][0] == "state": | |
| state_mapping_page() | |
| elif "page" in query_params and query_params["page"][0] == "subset": | |
| subset_page() | |
| elif "page" in query_params and query_params["page"][0] == "update": | |
| update_data() | |
| elif "page" in query_params and query_params["page"][0] == "district": | |
| district_page() | |
| elif "page" in query_params and query_params["page"][0] == "block": | |
| block_page() | |
| elif "page" in query_params and query_params["page"][0] == "panchayat": | |
| gp_page() | |
| elif "page" in query_params and query_params["page"][0] == "subdistrict": | |
| sub_district_page() | |
| elif "page" in query_params and query_params["page"][0] == "village": | |
| village_page() | |
| elif "page" in query_params and query_params["page"][0] == "insertRecord": | |
| pass | |
| #insert_record() | |
| else: | |
| home_page() | |
| # Main app logic | |
| def main(): | |
| st.set_page_config( | |
| page_title="CodeYatra", | |
| page_icon="🌟", | |
| layout="centered", | |
| initial_sidebar_state="expanded", | |
| ) | |
| page_route() | |
| def update_data(): | |
| st.title("Update the Corpus of LGD codes") | |
| if st.button('Update Corpus', key='corpus_button'): | |
| update_all_data() | |
| #sub set | |
| def subset_page(): | |
| st.title("Select Specific Columns from CSV/Excel File") | |
| # File uploader | |
| file = st.file_uploader("Upload a CSV or Excel file", type=["csv", "xlsx"]) | |
| if file is not None: | |
| # Process the file | |
| df = process_file(file) | |
| if df is not None: | |
| # Display the processed DataFrame | |
| st.write('Subsetted Columns') | |
| st.write(df.head()) | |
| st.info("Important: To perform LGD mapping accurately, please download the subsetted file. It contains the selected columns required for mapping. Without the subsetted file, LGD mapping cannot be done effectively.") | |
| st.warning("⚠️ **Important Notice:** Please upload the subsetted file on the next page for LGD mapping. It contains the required columns for accurate mapping.") | |
| # Download button | |
| csv = df.to_csv(index=False) | |
| b64 = base64.b64encode(csv.encode()).decode() | |
| href = f'<a href="data:file/csv;base64,{b64}" download="processed_data.csv">Download CSV</a>' | |
| st.markdown(href, unsafe_allow_html=True) | |
| if st.button('Start Mapping', key='mapping_button'): | |
| redirect_to_state_mapping_page() | |
| # State Mapping Code | |
| def state_mapping_page(dataset_selected=False): | |
| """ | |
| Generates the state mapping page which allows users to upload a CSV or Excel file containing a 'state_name' column. | |
| It then creates a mapped dataset which contains a state_code column based on the state_name column in the uploaded dataset. | |
| It also allows users to update the state name variations and download the mapped dataset. | |
| If the district_mapping_button is clicked, it redirects to the district mapping page. | |
| Parameters: | |
| ---------- | |
| dataset_selected: bool, optional | |
| Default value is False. If True, the 'dataset_file' is obtained from the session state. If False, it prompts the user to upload a dataset file. | |
| Returns: | |
| ---------- | |
| None | |
| """ | |
| st.title('State LGD Mapping') | |
| if not dataset_selected: | |
| dataset_file = st.file_uploader('Upload dataset', type=['csv', 'xlsx']) | |
| if dataset_file is None: | |
| st.warning("Please upload a dataset file.") | |
| return | |
| else: | |
| dataset_file = st.session_state['dataset_file'] | |
| dataset = pd.read_csv(dataset_file) if dataset_file.name.endswith('.csv') else pd.read_excel(dataset_file) | |
| if 'state_name' not in dataset.columns: | |
| st.error("Error: The dataset does not contain the 'state_name' column.") | |
| return | |
| st.subheader("Before State LGD Mapping") | |
| st.write(dataset.head()) | |
| with st.spinner("Processing..."): | |
| state_mapping = get_state_mappings() | |
| mapped_dataset = create_mapped_dataset(dataset, state_mapping) | |
| unmatched_names = mapped_dataset[mapped_dataset['state_code'] == -2]['state_name'] | |
| if unmatched_names.empty: | |
| st.success('No Unmatched State Names') | |
| mapped_dataset.to_csv('data.csv', index=False) | |
| st.subheader("After State LGD Mapping") | |
| with st.spinner("Processing..."): | |
| st.write(mapped_dataset.head()) | |
| generate_download_link(mapped_dataset) | |
| if st.button('Start District Mapping', key='district_mapping_button'): | |
| if 'district_name' not in mapped_dataset.columns: | |
| st.error("Error: The dataset does not contain the 'district_name' column.") | |
| return | |
| redirect_to_district_page() | |
| else: | |
| st.subheader('Unmatched State Names') | |
| st.write(unmatched_names.unique()) | |
| note = "Please provide the state name variations separated by commas or a single state name." | |
| st.info(note) | |
| st.subheader('Update State Name Variations') | |
| state_mapping = get_state_mappings() | |
| mapped_dataset = create_mapped_dataset(dataset, state_mapping) | |
| unmatched_names = mapped_dataset[mapped_dataset['state_code'] == -2]['state_name'] | |
| entity_table_name = "states" | |
| update_variations(unmatched_names.unique(), state_mapping, entity_table_name) | |
| unmatched_names = mapped_dataset[mapped_dataset['state_code'] == -2]['state_name'] | |
| if unmatched_names.empty: | |
| st.write(mapped_dataset.head()) | |
| mapped_dataset.to_csv('data.csv', index=False) | |
| generate_download_link(mapped_dataset) | |
| if st.button('Start District Mapping', key='district_mapping_button'): | |
| if 'district_name' not in mapped_dataset.columns: | |
| st.error("Error: The dataset does not contain the 'district_name' column.") | |
| return | |
| redirect_to_district_page() | |
| def district_page(): | |
| """ | |
| This function is responsible for displaying the District LGD mapping page. It fetches the district mapping dataset, | |
| maps the dataset, and downloads the mapped dataset. If there are any unmatched district names, it prompts the user to | |
| provide the district name variations. Once the district name variations are provided, it updates the entityNameVariants | |
| column in the SQLite table and generates a new mapped dataset for download. If the 'Start Sub-District/Block Mapping' | |
| button is clicked, it does nothing. | |
| """ | |
| st.title('District LGD Mapping') | |
| st.subheader("Before District LGD Mapping") | |
| state_dataset = load_file() | |
| st.write(state_dataset.head()) | |
| # Apply district mapping and create a new dataset | |
| data = fetch_district_mapping() | |
| district_mapping = populate_entity_mapping(data,'district_name','state_code') | |
| mapped_dataset = create_district_mapped_dataset(state_dataset, district_mapping) | |
| # Check if there are any unmatched names | |
| unmatched_names = mapped_dataset[mapped_dataset['district_code'] == -2]['district_name'] | |
| if unmatched_names.empty: | |
| # Display a message if there are no unmatched names | |
| st.success('No Unmatched district Names') | |
| mapped_dataset.to_csv("data.csv",index=False) | |
| # Create a CSV file in memory | |
| st.subheader("After District LGD Mapping") | |
| st.write(state_dataset.head()) | |
| generate_download_link(mapped_dataset) | |
| condition = True | |
| if 'sub_district_name' not in mapped_dataset.columns: | |
| condition = False | |
| if st.button('Start Block Mapping', key='block_mapping_button'): | |
| if 'block_name' not in mapped_dataset.columns: | |
| st.error("Error: The dataset does not contain the 'block_name' column.") | |
| return | |
| redirect_to_block_page() | |
| if condition: | |
| if st.button('Start Sub-District Mapping', key='sub-district_mapping_button'): | |
| if 'sub_district_name' not in mapped_dataset.columns: | |
| st.error("Error: The dataset does not contain the 'sub_district_name' column.") | |
| return | |
| redirect_to_sub_district_page() | |
| else: | |
| # Display the dataset with unmatched names | |
| st.subheader('Unmatched District Names') | |
| st.write(f'Unmatched District Count: '+str(len(unmatched_names.unique()))) | |
| st.write(unmatched_names.unique()) | |
| # Display the note | |
| note = "Please provide the district name variations separated by commas or a single district name." | |
| st.info(note) | |
| # Accept comma-separated values or single value only | |
| st.subheader('Update District Name Variations') | |
| #district_mapping = populate_entity_mapping(data,'district_name','state_code') | |
| #mapped_dataset = create_district_mapped_dataset(state_dataset, district_mapping) | |
| # Check if there are any unmatched names | |
| #unmatched_names = mapped_dataset[mapped_dataset['district_code'] == -2]['district_name'] | |
| district_names = [row[0] for row in data] | |
| entity_table_name = "district" | |
| update_variations(unmatched_names.unique(), district_names, entity_table_name) | |
| #unmatched_names = mapped_dataset[mapped_dataset['district_code'] == -2]['district_name'] | |
| if unmatched_names.empty: | |
| st.success('District Name Variations Updated Successfully.') | |
| # Create a CSV file in memory | |
| mapped_dataset.to_csv("data.csv",index=False) | |
| st.subheader("After District LGD Mapping") | |
| st.write(mapped_dataset.head()) | |
| generate_download_link(mapped_dataset) | |
| if 'block_name' in mapped_dataset.columns: | |
| if st.button('Start Block Mapping', key='block_mapping_button'): | |
| if 'block_name' not in mapped_dataset.columns: | |
| st.error("Error: The dataset does not contain the 'block_name' column.") | |
| return | |
| redirect_to_block_page() | |
| if 'sub_district_name' in mapped_dataset.columns: | |
| if st.button('Start Sub-District Mapping', key='sub-district_mapping_button'): | |
| if 'sub_district_name' not in mapped_dataset.columns: | |
| st.error("Error: The dataset does not contain the 'sub_district_name' column.") | |
| return | |
| redirect_to_sub_district_page() | |
| # Block mapping | |
| def block_page(): | |
| """ | |
| This function is responsible for displaying the block LGD mapping page. It fetches the block mapping dataset, | |
| maps the dataset, and downloads the mapped dataset. If there are any unmatched block names, it prompts the user to | |
| provide the block name variations. Once the block name variations are provided, it updates the entityNameVariants | |
| column in the SQLite table and generates a new mapped dataset for download. If the 'Start Sub-block/Block Mapping' | |
| button is clicked, it does nothing. | |
| """ | |
| st.title('Block LGD Mapping') | |
| st.subheader("Before Block LGD Mapping") | |
| block_dataset = pd.read_csv('data.csv') | |
| st.write(block_dataset.head()) | |
| data = fetch_block_mapping() | |
| # Apply block mapping and create a new dataset | |
| block_mapping = populate_entity_mapping(data,'block_name','district_code') | |
| mapped_dataset = create_block_mapped_dataset(block_dataset, block_mapping) | |
| # Check if there are any unmatched names | |
| unmatched_names = mapped_dataset[mapped_dataset['block_code'] == -2]['block_name'] | |
| if unmatched_names.empty: | |
| # Display a message if there are no unmatched names | |
| st.success('No Unmatched Block Names') | |
| # Create a CSV file in memory | |
| st.subheader("After Block LGD Mapping") | |
| mapped_dataset.to_csv("data.csv",index=False) | |
| st.write(mapped_dataset.head()) | |
| generate_download_link(mapped_dataset) | |
| if st.button('Start Panchayat Mapping', key='Panchayat_mapping_button'): | |
| if 'gp_name' not in mapped_dataset.columns: | |
| st.error("Error: The dataset does not contain the 'gp_name' column.") | |
| return | |
| redirect_to_panchayat_page() | |
| else: | |
| # Display the dataset with unmatched names | |
| st.subheader('Unmatched block Names') | |
| st.write(f'Unmatched block Count: '+str(len(unmatched_names.unique()))) | |
| st.write(unmatched_names.unique()) | |
| # Display the note | |
| note = "Please provide the block name variations separated by commas or a single block name." | |
| st.warning(note) | |
| # Accept comma-separated values or single value only | |
| st.subheader('Update Block Name Variations') | |
| entity_table_name = "block" | |
| block_mapping = populate_entity_mapping(data,'block_name','district_code') | |
| mapped_dataset = create_block_mapped_dataset(block_dataset, block_mapping) | |
| block_names = [row[0] for row in data] | |
| unmatched_names = mapped_dataset[mapped_dataset['block_code'] == -2]['block_name'] | |
| unmatched_names = unmatched_names.unique() | |
| update_variations(unmatched_names, block_names, entity_table_name) | |
| # Display a success message | |
| unmatched_names = mapped_dataset[mapped_dataset['block_code'] == -2]['block_name'] | |
| if unmatched_names.empty: | |
| st.success('Block Name Variations Updated Successfully.') | |
| # Create a CSV file in memory | |
| st.subheader("After block LGD Mapping") | |
| mapped_dataset.to_csv("data.csv",index=False) | |
| st.write(mapped_dataset.head()) | |
| generate_download_link(mapped_dataset) | |
| if st.button('Start Panchayat Mapping', key='Panchayat_mapping_button'): | |
| if 'gp_name' not in mapped_dataset.columns: | |
| st.error("Error: The dataset does not contain the 'gp_name' column.") | |
| return | |
| redirect_to_panchayat_page() | |
| #GP Mapping | |
| def gp_page(): | |
| """ | |
| This function is responsible for displaying the gp LGD mapping page. It fetches the gp mapping dataset, | |
| maps the dataset, and downloads the mapped dataset. If there are any unmatched gp names, it prompts the user to | |
| provide the gp name variations. Once the gp name variations are provided, it updates the entityNameVariants | |
| column in the SQLite table and generates a new mapped dataset for download. If the 'Start Sub-gp/gp Mapping' | |
| button is clicked, it does nothing. | |
| """ | |
| st.title('GP LGD Mapping') | |
| st.subheader("Before GP LGD Mapping") | |
| gp_dataset = pd.read_csv('data.csv') | |
| data= fetch_gp_mapping() | |
| st.write(gp_dataset.head()) | |
| unmatched_names = None | |
| # Apply gp mapping and create a new dataset | |
| #gp_mapping = populate_gp_mapping() | |
| gp_mapping = populate_entity_mapping(data,'gp_name','block_code') | |
| mapped_dataset = create_gp_mapped_dataset(gp_dataset, gp_mapping) | |
| # Check if there are any unmatched names | |
| unmatched_names = mapped_dataset[mapped_dataset['gp_code'] == -2]['gp_name'] | |
| if unmatched_names.empty: | |
| # Display a message if there are no unmatched names | |
| st.success('No Unmatched GP Names') | |
| # Create a CSV file in memory | |
| csv_file = mapped_dataset.to_csv(index=False) | |
| st.subheader("After GP LGD Mapping") | |
| st.write(mapped_dataset.head()) | |
| generate_download_link(mapped_dataset) | |
| if st.button('Start Village Mapping', key='village_mapping_button'): | |
| if 'village_name' not in mapped_dataset.columns: | |
| st.error("Error: The dataset does not contain the 'village_name' column.") | |
| return | |
| redirect_to_panchayat_page() | |
| else: | |
| # Display the dataset with unmatched names | |
| st.subheader('Unmatched GP Names') | |
| st.write(f'Unmatched GP Count: '+str(len(unmatched_names.unique()))) | |
| st.write(unmatched_names.unique()) | |
| # Display the note | |
| note = "Please provide the GP name variations separated by commas or a single GP name." | |
| st.info(note) | |
| # Accept comma-separated values or single value only | |
| st.subheader('Update GP Name Variations') | |
| gp_mapping = populate_gp_mapping() | |
| mapped_dataset = create_gp_mapped_dataset(gp_dataset, gp_mapping) | |
| entity_name = create_entity_name_list() | |
| # Check if there are any unmatched names | |
| unmatched_names = mapped_dataset[mapped_dataset['gp_code'] == -2]['gp_name'] | |
| update_variations(unmatched_names.unique(), entity_name, "gp") | |
| unmatched_names = mapped_dataset[mapped_dataset['gp_code'] == -2]['gp_name'] | |
| if unmatched_names.empty: | |
| st.success('GP Name Variations Updated Successfully.') | |
| # Create a CSV file in memory | |
| mapped_dataset.to_csv("data.csv",index=False) | |
| st.subheader("After GP LGD Mapping") | |
| st.write(mapped_dataset.head()) | |
| # Generate download link for the CSV file | |
| generate_download_link(mapped_dataset) | |
| if st.button('Start Village Mapping', key='village_mapping_button'): | |
| if 'village_name' not in mapped_dataset.columns: | |
| st.error("Error: The dataset does not contain the 'village_name' column.") | |
| return | |
| redirect_to_panchayat_page() | |
| #village page | |
| def village_page(): | |
| """ | |
| This function is responsible for displaying the village LGD mapping page. It fetches the village mapping dataset, | |
| maps the dataset, and downloads the mapped dataset. If there are any unmatched village names, it prompts the user to | |
| provide the village name variations. Once the village name variations are provided, it updates the entityNameVariants | |
| column in the SQLite table and generates a new mapped dataset for download. If the 'Start Sub-village/village Mapping' | |
| button is clicked, it does nothing. | |
| """ | |
| st.title('village LGD Mapping') | |
| st.subheader("Before village LGD Mapping") | |
| village_dataset = pd.read_csv('data.csv') | |
| st.write(village_dataset.head()) | |
| # Apply village mapping and create a new dataset | |
| village_mapping = populate_village_mapping() | |
| mapped_dataset = create_village_mapped_dataset(village_dataset, village_mapping) | |
| # Check if there are any unmatched names | |
| unmatched_names = mapped_dataset[mapped_dataset['village_code'] == -2]['village_name'] | |
| if unmatched_names.empty: | |
| # Display a message if there are no unmatched names | |
| st.success('No Unmatched Village Names') | |
| # Create a CSV file in memory | |
| st.subheader("After village LGD Mapping") | |
| st.write(mapped_dataset.head()) | |
| generate_download_link(mapped_dataset) | |
| else: | |
| # Display the dataset with unmatched names | |
| st.subheader('Unmatched village Names') | |
| st.write(f'Unmatched villages Count: '+str(len(unmatched_names.unique()))) | |
| st.write(unmatched_names.unique()) | |
| # Display the note | |
| note = "Please provide the village name variations separated by commas or a single village name." | |
| st.info(note) | |
| # Accept comma-separated values or single value only | |
| st.subheader('Update village Name Variations') | |
| village_mapping = populate_village_mapping() | |
| mapped_dataset = create_village_mapped_dataset(village_dataset, village_mapping) | |
| # Check if there are any unmatched names | |
| unmatched_names = mapped_dataset[mapped_dataset['village_code'] == -2]['panchayat_name'] | |
| update_variations(unmatched_names.unique(), village_mapping, "villages") | |
| unmatched_names = mapped_dataset[mapped_dataset['village_code'] == -2]['panchayat_name'] | |
| if unmatched_names.empty: | |
| st.success('village Name Variations Updated Successfully.') | |
| # Create a CSV file in memory | |
| mapped_dataset.to_csv("data.csv",index=False) | |
| st.subheader("After village LGD Mapping") | |
| st.write(mapped_dataset.head()) | |
| # Generate download link for the CSV file | |
| generate_download_link(mapped_dataset) | |
| #sub-district mapping | |
| def sub_district_page(): | |
| """ | |
| This function is responsible for displaying the Sub-District LGD mapping page. It fetches the Sub-District mapping dataset, | |
| maps the dataset, and downloads the mapped dataset. If there are any unmatched Sub-District names, it prompts the user to | |
| provide the Sub-District name variations. Once the Sub-District name variations are provided, it updates the entityNameVariants | |
| column in the SQLite table and generates a new mapped dataset for download. If the 'Start Sub-Sub-District/Sub-District Mapping' | |
| button is clicked, it does nothing. | |
| """ | |
| st.title('Sub-District LGD Mapping') | |
| st.subheader("Before Sub-District LGD Mapping") | |
| sub_district_dataset = pd.read_csv('data.csv') | |
| st.write(sub_district_dataset.head()) | |
| # Apply Sub-District mapping and create a new dataset | |
| sub_district_mapping = populate_sub_district_mapping() | |
| mapped_dataset = create_sub_district_mapped_dataset(sub_district_dataset, sub_district_mapping) | |
| # Check if there are any unmatched names | |
| unmatched_names = mapped_dataset[mapped_dataset['sub_district_code'] == -2]['sub_district_name'] | |
| if unmatched_names.empty: | |
| # Display a message if there are no unmatched names | |
| st.success('No Unmatched Sub-District Names') | |
| mapped_dataset.to_csv("data.csv",index=False) | |
| # Create a CSV file in memory | |
| generate_download_link(mapped_dataset) | |
| if st.button('Start Panchayat Mapping', key='Panchayat_mapping_button'): | |
| if 'panchayat_name' not in mapped_dataset.columns: | |
| st.error("Error: The dataset does not contain the 'panchayat_name' column.") | |
| return | |
| redirect_to_panchayat_page() | |
| else: | |
| # Display the dataset with unmatched names | |
| st.subheader('Unmatched Sub-District Names') | |
| st.write(f'Unmatched Sub-District Count: '+str(len(unmatched_names.unique()))) | |
| st.write(unmatched_names) | |
| # Display the note | |
| note = "Please provide the Sub-District name variations separated by commas or a single Sub-District name." | |
| st.info(note) | |
| # Accept comma-separated values or single value only | |
| st.subheader('Update Sub-District Name Variations') | |
| sub_district_mapping = populate_sub_district_mapping() | |
| mapped_dataset = create_sub_district_mapped_dataset(sub_district_dataset, sub_district_mapping) | |
| unmatched_names = mapped_dataset[mapped_dataset['sub_district_code'] == -2]['sub_district_name'] | |
| update_variations(unmatched_names.unique(), sub_district_mapping, "sub_district") | |
| unmatched_names = mapped_dataset[mapped_dataset['sub_district_code'] == -2]['sub_district_name'] | |
| if unmatched_names.empty: | |
| # Display a success message | |
| st.success('Sub-District Name Variations Updated Successfully.') | |
| # Create a CSV file in memory | |
| csv_file = mapped_dataset.to_csv(index=False) | |
| st.subheader("After Sub-District LGD Mapping") | |
| st.write(mapped_dataset.head()) | |
| mapped_dataset.to_csv("data.csv",index=False) | |
| st.write(mapped_dataset.head()) | |
| # Generate download link for the CSV file | |
| generate_download_link(mapped_dataset) | |
| if st.button('Start Panchayat Mapping', key='Panchayat_mapping_button'): | |
| if 'panchayat_name' not in mapped_dataset.columns: | |
| st.error("Error: The dataset does not contain the 'panchayat_name' column.") | |
| return | |
| redirect_to_panchayat_page() | |
| if __name__ == "__main__": | |
| main() |