Made a mistake in my designations for exposure_spread that I think was not counting any of the columns.

Add opponent mapping and conflict checks in exposure spread and lineup optimization functions; refactor data loading for MMA projections

Add data load tab functions to app.py and adjust GOLF flex rank calculation in predict_dupes.py for accurate portfolio predictions.

Refine dupe calculation for GOLF and CPT by incorporating FLEX1 and CPT ownership percentages, improving accuracy in portfolio predictions.

addressing a reoptimization issue

removing captain ownership from dupe calc for PGA showdown

Refactor ownership baseline calculations in predict_dupes.py to use set for unique team mapping, improving accuracy and performance.

more printing

printing debug

fixing predict_dupes

Refactor player update logic in projections management by removing redundant comments and enhancing ownership baseline calculations for NFL, NBA, and NHL sports. Adjusted baseline formulas to improve accuracy based on team mapping.

Enhance lineup optimization by adding cascading constraints and new parameters for objective value tracking. The optimize_single_lineup function now returns both the optimized row and the achieved objective value, allowing for more refined control over lineup adjustments. Additionally, the optimize_lineup function incorporates cascading optimization logic to ensure each row's objective is constrained by the previous row's performance.

Refactor projections management to use 'portfolio_inc_proj' for editing and optimize lineup filtering by excluding locked players. Cleaned up player pool logic to prevent duplicates.

ping

ping

ping

Enhance lineup optimization by tracking all players in the row and updating player pool filtering to exclude them. Adjusted constraints for player usage across open columns.

Update portfolio management to include player names from projections; fix lineup optimization constraint to use correct player column count.

Adding optimization

pulling the number up a bit

more adjustments to the way finishing percentiles are handled

adjusting own_baseline into finish_percentile calc

had to add the used of the ownership baseline into the reg dupe predictions

wrote the wrong min/max function

printing

Trying to do some team len scaling on ownership baselines

Update baseline logic in predict_dupes function to adjust own_baseline based on team count for NFL Classic type

adjusting finish percentile to scale

Refactor stratification logic to ensure proper selection of indices by adding break statements for clarity and control flow.

had to designate a maliable target

printing some lens

more strat testing

the while loop broke things, doing a range instead

Testing some new logic around stratification

Trying to fix the rerun of diversity score

Refactor 'Lineup Edge' calculation in predict_dupes.py to scale by Contest_Size for improved accuracy in contest performance metrics and apply clipping to ensure values remain within a specified range.

Update calculation of 'Lineup Edge' in predict_dupes.py to scale by 10000 for improved accuracy in contest performance metrics.

Adding exclusions from exposure management, fixing some database query stuff

ping

fixing the get_portfolio_names call

adjusting comp_salary_high out of equiation for Exposure Spread

aiming to fix dupes dropping while increasing size

almost ready

fixing load_csv

Add debug print statement to load_file function

updating load_csv to handle dataframes

ping

Enhance load_file function to ensure proper handling of unnamed columns by checking if the column name is a string before dropping. This improves data integrity during file uploads.

Enhance load_file function to check if the upload is already a DataFrame, improving handling of file uploads. This change simplifies the logic for processing uploaded data and ensures compatibility with existing DataFrame objects.

Refactor portfolio file loading to streamline assignment of DataFrames. The load_file function now returns both export and portfolio DataFrames in a single call, improving code clarity and efficiency.