import gradio as gr import threading import time import schedule import requests import urllib.parse from huggingface_hub import HfApi, Repository import os import math from datetime import datetime, timedelta import pandas as pd from workalendar.europe import Hungary from pandas.tseries.offsets import CustomBusinessDay import numpy as np import gspread from oauth2client.service_account import ServiceAccountCredentials import base64 import json from datasets import load_dataset, DatasetDict, Dataset from gradio.themes.base import Base import matplotlib.pyplot as plt from io import BytesIO from PIL import Image import random import httpx from collections import defaultdict #GET_MEDSERV_API AUTH: def medserv_authenticate(): # Get the payload from the environment variable MEDSERV_CREDS = os.getenv('MEDSERV_CREDS') if not MEDSERV_CREDS: print("Environment variable PAYLOAD not set.") return None try: # Parse the JSON string into a dictionary payload = json.loads(MEDSERV_CREDS) except json.JSONDecodeError: print("Failed to decode the JSON from the environment variable.") return None # Ensure both keys "azonosito" and "jelszo" are present if 'azonosito' not in payload or 'jelszo' not in payload: print("Payload must contain both 'azonosito' and 'jelszo'.") return None # Define the login URL login_url = 'https://api.lelet.medserv.hu/auth/login' # Send the POST request to the login endpoint with the JSON payload response = httpx.post(login_url, json=payload) # Check if authentication was successful (status code 200) if response.status_code == 200: # Extract the JWT token from the response token = response.json().get('jwt') if token: print("Authenticated successfully, token received.") return token else: print("Token not found in the response.") return None else: print(f"Failed to authenticate. Status code: {response.status_code}") print(f"Response: {response.text}") return None headers = { "Authorization": f"Bearer {medserv_authenticate()}", "Accept": "application/json" } def url_conversion(include_list): # Convert list to a JSON-like string format encoded_fields = json.dumps(include_list) # Encode into URL format return urllib.parse.quote_plus(encoded_fields) #GSHEETS_AUTH service_account_base64 = os.getenv('GSHEETS_KEY') # Decode the Base64 string to JSON try: service_account_json_str = base64.b64decode(service_account_base64).decode('utf-8') #print("Decoded service account JSON:", service_account_json_str[:100]) # Print a part for debugging except Exception as e: print("Error decoding service account:", e) # Parse the JSON string to a Python dictionary service_account_info = json.loads(service_account_json_str) scope = ["https://spreadsheets.google.com/feeds", "https://www.googleapis.com/auth/drive"] creds = ServiceAccountCredentials.from_json_keyfile_dict(service_account_info, scope) client = gspread.authorize(creds) #Retrieve google sheets smearshare_config_lims SMEARSHARE_URL ='https://docs.google.com/spreadsheets/d/1D7w_ewX37953fAZdGfJAc_pIHpCinlpK2YSsTuT4a3U/edit?gid=0#gid=0' smearshare_config = client.open_by_url(SMEARSHARE_URL).sheet1 smearshare_config_data = smearshare_config.get_all_records() smearshare_config_df = pd.DataFrame(smearshare_config_data) #Retrieve google sheets szabik SZABIK_URL = 'https://docs.google.com/spreadsheets/d/1Dh8wCA5i3w-t7sQWecbtcj2ZlidF3KhS8S-OS2JrMPg/edit?gid=0#gid=0' # Open the Google Sheet by URL or ID szabik_munkalap_1 = client.open_by_url(SZABIK_URL).sheet1 # or open_by_key(SHEET_ID) # Load the data into a DataFrame munkalap1_data = szabik_munkalap_1.get_all_records() szabik_df = pd.DataFrame(munkalap1_data) # FOR TESTING: # Calculate tomorrow's date tomorrow_date = datetime.now() + timedelta(days=0) #tomorrow_date = datetime(2025, 1, 6) # Format tomorrow's date as a string in the format "YYYY-MM-DD" current_date = tomorrow_date.strftime("%Y-%m-%d") # FOR DEPLOYING: #current_date = datetime.now().strftime("%Y-%m-%d") current_date_dt = pd.to_datetime(current_date) # Initialize HfApi repo_id = "drkvcsstvn/smear_share_testing" api_token = os.getenv("HF_API_TOKEN") api = HfApi(token=api_token) # Define the dataset repository name DATASET_NAME = "drkvcsstvn/TEST_smearshare_cumulative_distribution_lims" DISTRIBUTION_ACTIVITY_DATASET = "drkvcsstvn/TEST_smearshare_distribution_activity_lims" ALLOCATION_ACTIVITY_DATASET = "drkvcsstvn/TEST_smearshare_allocation_activity_lims" def restart_space(): response = api.restart_space(repo_id=repo_id) def delete_dataset(): try: response = api.delete_repo(repo_id=DATASET_NAME, repo_type="dataset") except Exception: print("Dataset not found or already deleted.") # Optional logging return None def schedule_restart(): # Schedule the restart every minute # FOR TESTING: #schedule.every(3).minutes.do(restart_space) schedule.every(5).minutes.do(push_daily_activity) # Schedule daily push before restart #schedule.every().day.at("02:50").do(push_daily_activity) # Push at 02:50 #schedule.every().day.at("02:55").do(delete_dataset) #schedule.every().day.at("03:00").do(restart_space) while True: schedule.run_pending() time.sleep(60) def start_scheduler(): # Start the scheduler in a separate thread scheduler_thread = threading.Thread(target=schedule_restart, daemon=True) scheduler_thread.start() # Function to save cumulative_distribution to Hugging Face dataset def save_cumulative_distribution(cumulative_distribution): # Convert cumulative_distribution to a DataFrame df = pd.DataFrame(list(cumulative_distribution.items()), columns=['Peeler', 'Total']) # Convert DataFrame to Dataset dataset = Dataset.from_pandas(df) dataset.push_to_hub(DATASET_NAME, split="train", token=api_token) print(f"Dataset pushed to {DATASET_NAME}") # In-memory storage for daily activities daily_distribution_activity = {} daily_allocation_activity = [] def save_distribution_activity(cumulative_distribution): """ Accumulate activity instead of pushing immediately """ global daily_distribution_activity for peeler, total in cumulative_distribution.items(): daily_distribution_activity[peeler] = daily_distribution_activity.get(peeler, 0) + total def save_allocation_activity(onbehalf_of_user, target_selection): """ Accumulate allocation activity instead of pushing immediately """ global daily_allocation_activity daily_allocation_activity.append({ "Timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S"), "User": onbehalf_of_user, "Választó": target_selection }) def push_daily_activity(): """ Pushes accumulated activities to the Hub once per day """ global daily_distribution_activity, daily_allocation_activity # Push distribution activity if daily_distribution_activity: df = pd.DataFrame(list(daily_distribution_activity.items()), columns=['Peeler', 'Total']) try: existing_dataset = load_dataset(DISTRIBUTION_ACTIVITY_DATASET, split="train", token=api_token) existing_df = existing_dataset.to_pandas() updated_df = pd.merge(existing_df, df, on='Peeler', how='outer', suffixes=('_existing', '_new')) updated_df['Total'] = updated_df['Total_existing'].fillna(0) + updated_df['Total_new'].fillna(0) updated_df = updated_df[['Peeler', 'Total']] except Exception: updated_df = df Dataset.from_pandas(updated_df).push_to_hub(DISTRIBUTION_ACTIVITY_DATASET, split="train", token=api_token) # Push allocation activity if daily_allocation_activity: df = pd.DataFrame(daily_allocation_activity) try: existing_dataset = load_dataset(ALLOCATION_ACTIVITY_DATASET, split="train", token=api_token) existing_df = existing_dataset.to_pandas() updated_df = pd.concat([existing_df, df], ignore_index=True) except Exception: updated_df = df Dataset.from_pandas(updated_df).push_to_hub(ALLOCATION_ACTIVITY_DATASET, split="train", token=api_token) # Clear in-memory storage daily_distribution_activity.clear() daily_allocation_activity.clear() print("Daily activity pushed and cleared.") # Function to load cumulative_distribution from Hugging Face dataset def load_cumulative_distribution(): try: dataset = load_dataset(DATASET_NAME, split="train", token=api_token) if len(dataset) == 0: print("Dataset is empty. Initializing cumulative_distribution from medserv.") return cumulative_distribution_from_medserv df = dataset.to_pandas() cumulative_distribution = dict(zip(df['Peeler'], df['Total'])) return cumulative_distribution except Exception as e: print(f"Error loading cumulative distribution: {e}") return {peeler: 0 for peeler in peeler_capacities} def update_cumulative_distribution(new_distribution): cumulative_dict = cumulative_distribution # Update cumulative distribution with new values for name, count in new_distribution.items(): # Find the peeler ID based on name peeler_id = next((id for id, peeler_name in peeler_names.items() if peeler_name == name), None) if peeler_id is not None: # Add count to existing value if peeler_id in cumulative_dict: cumulative_dict[peeler_id] += count else: cumulative_dict[peeler_id] = count return cumulative_dict # Peeler names peeler_names = dict(zip(smearshare_config_df['peelers'], smearshare_config_df['peeler_names'])) # Create a dictionary mapping peelers to their capacities peeler_capacities = dict(zip(smearshare_config_df['peelers'], smearshare_config_df['peeler_capacities'])) peeler_azo = dict(zip(smearshare_config_df['peeler_azo'], smearshare_config_df['peelers'])) peeler_name_azo = dict(zip(smearshare_config_df['peeler_names'], smearshare_config_df['peeler_azo'])) #print(peeler_azo) # Start Cumulative from Medserv cumulative_include_list = [ 'id', 'lelet_kelte', 'adatok_taj', 'lelet_eloszuro_nev', 'lelet_leletezo_orvos_1_nev' ] # Calculate the date six months ago half_year_earlier = tomorrow_date - timedelta(days=180) # 180 lelet_kelte_start_date = half_year_earlier.strftime("%Y-%m-%d") # URL for cumulative distribution data cumulative_distribution_url = f"https://api.lelet.medserv.hu/cytology/grid?include={url_conversion(cumulative_include_list)}&sort=%5B%7B%22letrehozva%22:-1%7D%5D&where=%7B%22and%22:%5B%7B%22lelet_kelte%22:%7B%22gte%22:%22{lelet_kelte_start_date}%22%7D%7D%5D%7D" def fetch_all_data(url, headers, batch_size=12000): """Fetch all paginated data from the specified URL.""" all_data = [] skip = 0 while True: paginated_url = f"{url}&skip={skip}&limit={batch_size}" response = requests.get(paginated_url, headers=headers) if response.status_code == 200: data = response.json() rows = data.get('rows', []) if not rows: # Break if no more data is returned break all_data.extend(rows) # Append new records to all_data skip += batch_size # Increment skip for the next batch else: print(f"Error: {response.status_code}") print(response.text) break return all_data # Fetch and process cumulative data fetched_df_for_cumulative = pd.DataFrame(fetch_all_data(cumulative_distribution_url, headers)) format_fetched_df_for_cumulative = fetched_df_for_cumulative.groupby(['lelet_leletezo_orvos_1_nev']).count()['id'].reset_index() # Function to format the names def format_name(name): # Remove "Dr." and split the name into parts parts = name.replace("Dr. ", "").split() # Keep the 2nd and 3rd elements, if they exist return ' '.join(parts[0:2]) if len(parts) >= 2 else '' # Apply the formatting function to the 'names' column format_fetched_df_for_cumulative['peeler_names'] = format_fetched_df_for_cumulative['lelet_leletezo_orvos_1_nev'].apply(format_name) format_fetched_df_for_cumulative = format_fetched_df_for_cumulative[['peeler_names','id']] format_fetched_df_for_cumulative.rename(columns={'id': 'Total'}, inplace=True) #Dropping Babarczi Edit from Dataframe: format_fetched_df_for_cumulative = format_fetched_df_for_cumulative[format_fetched_df_for_cumulative['peeler_names'] != 'Kiss Zsombor'] # Merge DataFrames merged_cumulative = pd.merge(format_fetched_df_for_cumulative, smearshare_config_df, on= 'peeler_names',how='left')[['peelers','peeler_names','Total']] # Convert the values to numeric by extracting the number part # The regex extracts digits and converts them to integers merged_cumulative['numeric_part'] = merged_cumulative['peelers'].str.extract('(\d+)').astype(float) # Calculate the maximum value pmax = merged_cumulative['numeric_part'].max() # Find the indices of NaN values na_indices = merged_cumulative[merged_cumulative['peelers'].isna()].index # Fill NaN values with pmax + 1, pmax + 2, ... for i, index in enumerate(na_indices): merged_cumulative.at[index, 'peelers'] = f'P{int(pmax) + i + 1}' # Optionally, drop the temporary numeric part column if not needed merged_cumulative = merged_cumulative.drop(columns='numeric_part') # Create a dictionary for cumulative distribution cumulative_distribution_from_medserv = dict(zip(merged_cumulative['peelers'], merged_cumulative['Total'])) save_cumulative_distribution(cumulative_distribution_from_medserv) #Updating smearshare_config_df try: # Updating smearshare_config_df update_smearshare_config_df = pd.merge(merged_cumulative, smearshare_config_df, on=['peelers', 'peeler_names'], how='outer') # Step 1: Handle NaN values numeric_columns = ['peeler_azo','peeler_capacities', 'capacity_weight', 'vacation_buffer', 'cumulative_impact', 'tomorrow_date'] update_smearshare_config_df[numeric_columns] = update_smearshare_config_df[numeric_columns].fillna(0) # Dropping the 'Total' column update_smearshare_config_df = update_smearshare_config_df.drop('Total', axis=1) # Sorting by 'peelers' update_smearshare_config_df = update_smearshare_config_df.sort_values(by=['peelers']) # Clear existing content in the Google Sheet smearshare_config.clear() # Convert DataFrame to list of lists data_to_update = [update_smearshare_config_df.columns.values.tolist()] + update_smearshare_config_df.values.tolist() # Update the Google Sheet response = smearshare_config.update(data_to_update) print("Update response:", response) except Exception as e: print("An error occurred:", e) # Log additional details for debugging print("Error details:") #print(f"DataFrame to update:\n{update_smearshare_config_df.head()}") #print(f"Data sent to Google Sheets:\n{data_to_update[:5]}") # Create a custom business day excluding the holidays / NOT IN USE NOW # Initialize the calendar for Hungary cal = Hungary() current_year = datetime.now().year special_days_include_list = ['datum','tipus','megnevezes'] special_days_url = f"https://api.lelet.medserv.hu/special-day/grid?include={url_conversion(special_days_include_list)}&sort=%5B%7B%22datum%22:-1%7D%5D&where=%7B%22and%22:%5B%7B%22datum%22:%7B%22contain%22:%22{current_year}%22%7D%7D%5D%7D&skip=0&limit=100" response = requests.get(special_days_url, headers=headers) data = response.json() # Check if the response contains any data if isinstance(data, dict) and 'rows' in data and len(data['rows']) == 0: print("Problem: No data found.") else: print("Data retrieved successfully.") # Creating two separate lists for 'Munkaszüneti nap' and 'Munkanap' custom_holidays = pd.to_datetime([item['datum'] for item in data['rows'] if item['tipus'] == 'Munkaszüneti nap']).tolist() additional_workdays = pd.to_datetime([item['datum'] for item in data['rows'] if item['tipus'] == 'Munkanap']) # Get the holidays for the year hungarian_holidays = cal.holidays(int(current_year)) hungarian_holidays_dates = [pd.Timestamp(date) for date, _ in hungarian_holidays] combined_holidays = sorted(set(hungarian_holidays_dates + custom_holidays) - set(additional_workdays)) custom_business_day = CustomBusinessDay(holidays=combined_holidays) # Generate all business days for the remainder of 2024 remaining_workdays = pd.date_range(start=current_date_dt, end=f"{str(int(current_year)+1)}-12-31", freq=custom_business_day) # Combine remaining workdays with additional workdays, remove duplicates, and sort #workdays_df = pd.DataFrame(pd.concat([pd.Series(remaining_workdays), pd.Series(additional_workdays)]).drop_duplicates().sort_values(), columns=["Workday"]) # Define the start date (6 months before) and end date (6 months after) workdays_df_start_date = datetime.now() - pd.DateOffset(months=6) workdays_df_end_date = datetime.now() + pd.DateOffset(months=6) # Generate a date range for all days between the start and end dates workdays_df_all_days = pd.date_range(start=workdays_df_start_date, end=workdays_df_end_date) # Create a DataFrame with the 'Workday' column in datetime64[ns] format workdays_df = pd.DataFrame(workdays_df_all_days, columns=["Workday"]) # Format the 'Workday' column to display as 'YYYY-MM-DD' workdays_df["Workday"] = workdays_df["Workday"].dt.strftime('%Y-%m-%d') # Ensure the 'Workday' column is in datetime64[ns] format (this should already be the case) workdays_df["Workday"] = pd.to_datetime(workdays_df["Workday"]) #print(workdays_df) #print(workdays_df.dtypes) workers = smearshare_config_df['peeler_names'].to_list() # Function to shuffle workers def shuffle_workers(workers): shuffled = workers.copy() np.random.shuffle(shuffled) return shuffled # Add a column 'Active' with shuffled worker names for each day workdays_df['Active'] = workdays_df['Workday'].apply(lambda x: shuffle_workers(workers)) # Vacation data #szabik_df = pd.read_csv('szabik - Munkalap1.csv') # Convert Start Date and End Date to datetime objects szabik_df["Szabi Kezdete"] = pd.to_datetime(szabik_df["Szabi Kezdete"]) szabik_df["Szabi Vége"] = pd.to_datetime(szabik_df["Szabi Vége"]) # Calculate one workday before each vacation start date szabik_df["Two Days Before Start Date"] = szabik_df["Szabi Kezdete"] - custom_business_day - timedelta(days=1) # Calculate one week before vacation for Bori Rita and Serényi Péter szabik_df["One Week Before Vacation"] = szabik_df["Szabi Kezdete"] - timedelta(weeks=1) # Update 'Active' column by removing workers on vacation def remove_vacationers(workday, active_workers): # Iterate over the vacation dataframe for _, vacation in szabik_df.iterrows(): # Remove workers on vacation during the workday if vacation["Two Days Before Start Date"] <= workday < vacation["Szabi Vége"]: if vacation["Név"] in active_workers: active_workers.remove(vacation["Név"]) # Specifically for Bori Rita and Serényi Péter, remove them one week before their vacation if vacation["Név"] in ["Bori Rita", "Serényi Péter"]: if vacation["One Week Before Vacation"] <= workday < vacation["Szabi Vége"]: if vacation["Név"] in active_workers: active_workers.remove(vacation["Név"]) # Exclude Bori Rita and Serényi Péter on Thursdays and Fridays #if workday.weekday() not in [2, 3, 4]: # Wednesday:2, Thursday: 3, Friday: 4 # active_workers = [worker for worker in active_workers if worker not in ["Bori Rita", "Serényi Péter"]] return active_workers # Apply the removal function to update the 'Active' column workdays_df['Active'] = workdays_df.apply( lambda row: remove_vacationers(row['Workday'], row['Active']), axis=1 ) #print(szabik_df[['Név', 'Szabi Kezdete', 'Two Days Before Start Date']]) #print(workdays_df[workdays_df['Workday']>= current_date]) # Track cumulative distribution # Function to get active peelers for the current date def get_active_peelers(workdays_df, current_date): try: return workdays_df.loc[workdays_df['Workday'] == current_date, 'Active'].values[0] except IndexError: return [] # Define the function to calculate dynamic vacation buffer during the grace period def dynamic_vacation_buffer(worker_name, workday, szabik_df, custom_business_day, grace_period_days=4, default_vacation_buffer=smearshare_config_df['vacation_buffer'].iloc[0]): #print(f"Default vacation buffer: {default_vacation_buffer}") # Debugging: Print the default buffer value # Filter for the specific worker's vacation records worker_vacations = szabik_df[szabik_df["Név"] == worker_name] for _, vacation in worker_vacations.iterrows(): if vacation["Szabi Vége"] < workday <= vacation["Szabi Vége"] + timedelta(days=grace_period_days): # Check if the vacation lasted more than one week (7 days) vacation_length = (vacation["Szabi Vége"] - vacation["Szabi Kezdete"]).days if vacation_length > 7: grace_period_days += 1 # Add one day for vacations longer than a week # Calculate valid workdays grace_period_start = vacation["Szabi Vége"] + timedelta(days=1) # Start from the next day after vacation ends valid_workdays = pd.date_range(start=grace_period_start, end=workday, freq=custom_business_day) days_since_vacation = len(valid_workdays) # If it's the first day back, return the default vacation buffer if days_since_vacation == 1: #print(f'First day after vacation for {worker_name}, default vacation buffer:{default_vacation_buffer}') return default_vacation_buffer # Diminishing buffer calculation diminishing_buffer = max(1, default_vacation_buffer - ((days_since_vacation / grace_period_days) * (default_vacation_buffer - 1))) #print(f'Diminishing buffer for {worker_name}: {diminishing_buffer}') return diminishing_buffer #print(f'No relevant vacation data found for {worker_name} on {workday}. Returning default factor of 1.') return 1 # If not in grace period, return 1 #load_cumulative distribution once!! cumulative_distribution = load_cumulative_distribution() # Function to calculate potato distribution def calculate_distribution(num_potatoes, active_peelers, peeler_names, workday, szabik_df): valid_active_peelers = [p for p in active_peelers if p in peeler_capacities] #cumulative_distribution = load_cumulative_distribution() if not valid_active_peelers: return {peeler_names[p]: 0 for p in active_peelers} # Retrieve capacity weight and vacation buffer using the helper function capacity_weight = smearshare_config_df['capacity_weight'].iloc[0] cumulative_impact = smearshare_config_df['cumulative_impact'].iloc[0] #print(f'Capacity weight:{capacity_weight}') #print(f'Cumulative impact: {cumulative_impact}') adjusted_weights = {} for peeler in valid_active_peelers: capacity = peeler_capacities[peeler] #print(f'Capacity:{capacity}') # Calculate the cumulative proportion of potatoes handled by the peeler total_potatoes_processed = sum(cumulative_distribution.values()) or 1 # Avoid division by zero peeler_proportion = cumulative_distribution.get(peeler, 0) / total_potatoes_processed # Apply non-linear scaling to peeler_proportion to reduce the impact non_linear_proportion = peeler_proportion ** cumulative_impact # You can adjust this for different effects # Adjust the weight using the dynamically diminishing vacation buffer during grace period vacation_buffer = dynamic_vacation_buffer(peeler_names[peeler], workday, szabik_df, custom_business_day) adjusted_weight = (capacity * capacity_weight) / (1 + non_linear_proportion * vacation_buffer) adjusted_weights[peeler] = adjusted_weight #print(f"Adjusted Weights: {adjusted_weights}") total_weight = sum(adjusted_weights.values()) if total_weight == 0: return {peeler_names[p]: 0 for p in valid_active_peelers} raw_distribution = {peeler: (num_potatoes * adjusted_weights[peeler]) / total_weight for peeler in valid_active_peelers} #print(f"Raw Distribution: {raw_distribution}") whole_distribution = {peeler: math.floor(potatoes) for peeler, potatoes in raw_distribution.items()} total_distributed = sum(whole_distribution.values()) remaining_potatoes = num_potatoes - total_distributed if remaining_potatoes > 0: for i in range(remaining_potatoes): peeler = valid_active_peelers[i % len(valid_active_peelers)] whole_distribution[peeler] += 1 #for peeler in valid_active_peelers: # cumulative_distribution[peeler] += whole_distribution[peeler] # save_cumulative_distribution(cumulative_distribution) return {peeler_names[peeler]: whole_distribution[peeler] for peeler in valid_active_peelers} target_list = ['supervisor','orvos','special'] def distribute_potatoes(onbehalf_of_user, target, spec_peeler_azo = None): #onBehalfOfUser: S34151 #azo,id #target: supervisor | orvos | special #spec_peeler: null | “O12345” active_peelers = get_active_peelers(workdays_df, current_date_dt) # Map keys based on active_peelers values if not active_peelers: return "A mai napon nem adható fel kenet konzultációra." active_peeler_ids = {id: name for id, name in peeler_names.items() if name in active_peelers} # Separate peelers for red and blue potatoes red_peelers = [id for id in active_peeler_ids if id in ["P7", "P8"] and id != peeler_azo.get(onbehalf_of_user)] blue_peelers = [id for id in active_peeler_ids if id in ["P1", "P13", "P2","P3", "P4","P5","P6"] and id != peeler_azo.get(onbehalf_of_user)] # Shuffle the red and blue peelers to avoid bias in distribution random.shuffle(red_peelers) random.shuffle(blue_peelers) # Calculate initial distribution for all active peelers def calculate_initial_distribution(peelers): # Calculate and return the initial distribution return calculate_distribution(1, peelers, peeler_names, current_date_dt, szabik_df) if target == 'supervisor': final_distribution = calculate_initial_distribution(red_peelers) cumulative_distribution = update_cumulative_distribution(final_distribution) print(cumulative_distribution) save_distribution_activity(final_distribution) save_allocation_activity(onbehalf_of_user, "general") # Get the names where the value is greater than 0 final_name = [key for key, value in final_distribution.items() if value > 0] return peeler_name_azo.get(final_name[0]) elif target == 'orvos': final_distribution = calculate_initial_distribution(blue_peelers) cumulative_distribution = update_cumulative_distribution(final_distribution) print(cumulative_distribution) save_distribution_activity(final_distribution) save_allocation_activity(onbehalf_of_user, "general") final_name = [key for key, value in final_distribution.items() if value > 0] return peeler_name_azo.get(final_name[0]) elif target == 'special': if spec_peeler_azo is None: return "No spec_peeler_azo provided for special distribution." if spec_peeler_azo not in get_active_peelers_azo(): return " A kiválasztott konzulens nem aktív" # Fordított szótár létrehozása azo_to_peeler_name = {v: k for k, v in peeler_name_azo.items()} # Megkeresni a nevet a spec_peeler_azo alapján spec_peeler_name = azo_to_peeler_name.get(spec_peeler_azo) # Létrehozni a final_distribution-t final_distribution = {spec_peeler_name: 1} cumulative_distribution = update_cumulative_distribution(final_distribution) print(cumulative_distribution) save_distribution_activity(final_distribution) save_allocation_activity(onbehalf_of_user, "special") return spec_peeler_azo # Create Gradio interface class Seafoam(Base): pass gradio_theme = Seafoam() def get_active_peelers_azo(): return [v for k,v in peeler_name_azo.items() if k in get_active_peelers(workdays_df, current_date_dt)] # Gradio app definition with gr.Blocks(theme=gradio_theme) as demo: gr.Markdown(f"

Smear/Share - {current_date}

") with gr.Column(): user_input = gr.Number(label="Onbehalf_of_user") target_input = gr.Dropdown(choices=target_list, label="Target_list") special_input = gr.Dropdown(choices=get_active_peelers_azo(), label="Specifikus konzulens") with gr.Row(): share_button = gr.Button("Szétosztás", variant="primary") active_peelers_button = gr.Button("Aktív konzulensek", variant="primary") with gr.Column(): output_box = gr.Textbox(label="Konzulens") active_peelers_output = gr.Textbox(label="Aktív dolgozók") # Share button action share_button.click( fn=lambda user, target, special: ( distribute_potatoes(user, target, special) ), inputs=[user_input, target_input, special_input], outputs=[output_box] ).then( fn=lambda: (None, None, None), # Reset all inputs inputs=[], outputs=[user_input, target_input, special_input] ) active_peelers_button.click( fn= get_active_peelers_azo, outputs=[active_peelers_output] ) # Launch the main Gradio app with the API endpoint exposed demo.launch()