Update app.py

app.py

@@ -388,12 +388,161 @@ def get_well_position(sample_index):
     col_number = ((sample_index - 1) % 12) + 1
     return f"{row_letter}{col_number}"
 
+# # Tab 5: Binary → String
+# with tab5: 
+#     st.header("Decode Binary Labels to String")
+
+#     # Utility: Track source volumes and update if exceeds limit
+#     def track_and_replace_source(source_list, robot_script, volume_limit=180):
+#         source_volumes = {}
+#         adjusted_sources = []
+
+#         for entry in robot_script:
+#             src = entry['Source']
+#             vol = entry['Volume']
+
+#             if src not in source_volumes:
+#                 source_volumes[src] = 0
+
+#             source_volumes[src] += vol
+
+#             if source_volumes[src] > volume_limit:
+#                 row_letter = src[0]
+#                 col_number = src[1:]
+#                 new_row_letter = chr(ord(row_letter) + 4)
+#                 new_src = f"{new_row_letter}{col_number}"
+#                 entry['Source'] = new_src
+
+#                 if new_src not in source_volumes:
+#                     source_volumes[new_src] = 0
+#                 source_volumes[new_src] += vol
+#                 source_volumes[src] -= vol
+
+#             adjusted_sources.append(entry)
+
+#         return adjusted_sources, source_volumes
+
+#     # Utility: Generate fixed-volume D source to all sample wells
+#     def generate_fixed_d_source_instructions_to_all_samples(n_samples, fixed_volume=16, volume_limit=170):
+#         d_source_volumes = {}
+#         d_source_script = []
+#         current_d_index = 1
+
+#         for i in range(n_samples):
+#             dest = get_well_position(i + 1)
+#             current_d_well = f"D{current_d_index}"
+
+#             if current_d_well not in d_source_volumes:
+#                 d_source_volumes[current_d_well] = 0
+
+#             if d_source_volumes[current_d_well] + fixed_volume > volume_limit:
+#                 current_d_index += 1
+#                 current_d_well = f"D{current_d_index}"
+#                 d_source_volumes[current_d_well] = 0
+
+#             d_source_volumes[current_d_well] += fixed_volume
+#             tool = 'TS_10' if fixed_volume < 10 else 'TS_50'
+
+#             d_source_script.append({
+#                 'Source': current_d_well,
+#                 'Destination': dest,
+#                 'Volume': fixed_volume,
+#                 'Tool': tool
+#             })
+
+#         return d_source_script, d_source_volumes
+
+#     def generate_source_wells(n):
+#         wells = []
+#         rows = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
+#         for i in range(n):
+#             row = rows[i // 12]  # cycle through A, B, C...
+#             col = (i % 12) + 1    # 1 to 12
+#             wells.append(f"{row}{col}")
+#         return wells
+
+#     st.subheader("Binary per Row")
+#     st.write("Upload CSV with any number of columns (0 or 1), no headers, from EF Binary format or enter manually below.")
+
+#     binary32_file = st.file_uploader("Upload Binary CSV", type=["csv"], key="binary_any")
+
+#     st.subheader("Optional Metadata (Optional)")
+#     barcode_id_input = st.text_input("Barcode ID (applied to all rows, optional)", value="")
+#     labware_source_input = st.text_input("Labware for Source (optional, default = 1)", value="1")
+#     labware_dest_input = st.text_input("Labware for Destination (optional, default = 1)", value="1")
+#     name_input = st.text_input("Name field (optional, default = blank)", value="")
+
+#     if binary32_file:
+#         df_32 = pd.read_csv(binary32_file, header=None)
+#         df_32.columns = [str(h) for h in range(1, len(df_32.columns)+1)]
+#     else:
+#         df_32 = st.data_editor(
+#             pd.DataFrame(columns=[str(h) for h in range(1, 33)]),
+#             num_rows="dynamic",
+#             key="manual_any_input"
+#         )
+
+#     if not df_32.empty:
+#         st.subheader("Binary Labels (Uploaded)")
+#         st.dataframe(df_32.style.applymap(lambda v: "background-color: lightgreen" if v == 1 else "background-color: lightcoral"))
+#         st.download_button("Download CSV", df_32.to_csv(index=False), "decoded_binary_uploaded.csv", key="download_csv_uploaded")
+
+#         decoded = binary_labels_to_string(df_32.values.flatten().astype(int).tolist())
+#         st.subheader("Decoded String")
+#         st.write(decoded)
+#         st.download_button("Download Concatenated Output", decoded, "decoded_binary_string.txt", key="download_txt_any")
+
+#         st.subheader("Robot Preparation Script from Binary")
+
+#         df_32_robot = df_32.copy()
+#         df_32_robot.insert(0, 'Sample', range(1, len(df_32_robot)+1))
+#         df_32_robot['# donors'] = df_32_robot.iloc[:, 1:].astype(int).sum(axis=1)
+#         df_32_robot['volume donors (µl)'] = 64 / df_32_robot['# donors']
+
+#         robot_script_32 = []
+#         source_wells_32 = generate_source_wells(df_32.shape[1])
+
+#         for i, col in enumerate(df_32.columns):
+#             for row_idx, sample in df_32_robot.iterrows():
+#                 if int(sample[col]) == 1:
+#                     source = source_wells_32[i]
+#                     dest = get_well_position(int(sample['Sample']))
+#                     vol = round(sample['volume donors (µl)'], 2)
+#                     tool = 'TS_10' if vol < 10 else 'TS_50'
+#                     robot_script_32.append({
+#                         'Source': source,
+#                         'Destination': dest,
+#                         'Volume': vol,
+#                         'Tool': tool
+#                     })
+
+#         robot_script_32, source_volumes_32 = track_and_replace_source(source_wells_32, robot_script_32)
+
+#         d_script, d_volumes = generate_fixed_d_source_instructions_to_all_samples(len(df_32_robot))
+#         full_robot_script = robot_script_32 + d_script
+
+#         robot_script_32_df = pd.DataFrame(full_robot_script)
+#         robot_script_32_df.insert(0, 'Barcode ID', barcode_id_input)
+#         robot_script_32_df.insert(1, 'Labware_Source', labware_source_input)
+#         robot_script_32_df.insert(3, 'Labware_Destination', labware_dest_input)
+#         robot_script_32_df['Name'] = name_input
+#         robot_script_32_df = robot_script_32_df[['Barcode ID', 'Labware_Source', 'Source', 'Labware_Destination', 'Destination', 'Volume', 'Tool', 'Name']]
+
+#         st.dataframe(robot_script_32_df)
+#         st.download_button("Download Robot Script", robot_script_32_df.to_csv(index=False), "robot_script.csv", key="download_robot_any")
+
+#         st.subheader("Total Volume Used Per Source")
+#         combined_volumes = {**source_volumes_32, **d_volumes}
+#         source_volume_df = pd.DataFrame(list(combined_volumes.items()), columns=['Source', 'Total Volume (µl)'])
+#         st.dataframe(source_volume_df)
+#         st.download_button("Download Source Volumes", source_volume_df.to_csv(index=False), "source_total_volumes.csv", key="download_volume_any")
+
 # Tab 5: Binary → String
 with tab5: 
     st.header("Decode Binary Labels to String")
 
     # Utility: Track source volumes and update if exceeds limit
-    def track_and_replace_source(source_list, robot_script, volume_limit=180):
+    def track_and_replace_source(source_list, robot_script, volume_limit):
         source_volumes = {}
         adjusted_sources = []
 
@@ -441,13 +590,12 @@ with tab5:
                 d_source_volumes[current_d_well] = 0
 
             d_source_volumes[current_d_well] += fixed_volume
-            tool = 'TS_10' if fixed_volume < 10 else 'TS_50'
 
             d_source_script.append({
                 'Source': current_d_well,
                 'Destination': dest,
                 'Volume': fixed_volume,
-                'Tool': tool
+                'Tool': 'TS_10'
             })
 
         return d_source_script, d_source_volumes
@@ -461,38 +609,51 @@ with tab5:
             wells.append(f"{row}{col}")
         return wells
 
-    st.subheader("Binary per Row")
-    st.write("Upload CSV with any number of columns (0 or 1), no headers, from EF Binary format or enter manually below.")
+    # ========== 32-BIT DECODING ==========
+    st.subheader("32-bit Binary per Row")
+    st.write("Upload CSV with 32 columns (0 or 1), no headers, from EF Binary format or enter manually below.")
 
-    binary32_file = st.file_uploader("Upload Binary CSV", type=["csv"], key="binary_any")
+    binary32_file = st.file_uploader("Upload 32-bit Binary CSV", type=["csv"], key="binary_32")
 
     st.subheader("Optional Metadata (Optional)")
     barcode_id_input = st.text_input("Barcode ID (applied to all rows, optional)", value="")
     labware_source_input = st.text_input("Labware for Source (optional, default = 1)", value="1")
     labware_dest_input = st.text_input("Labware for Destination (optional, default = 1)", value="1")
     name_input = st.text_input("Name field (optional, default = blank)", value="")
+    volume_limit_input = st.number_input("Volume limit per source well (µl)", min_value=1, max_value=500, value=180, step=10)
 
     if binary32_file:
         df_32 = pd.read_csv(binary32_file, header=None)
-        df_32.columns = [str(h) for h in range(1, len(df_32.columns)+1)]
+        df_32.columns = [str(h) for h in mutation_site_headers_actual_3614]
     else:
         df_32 = st.data_editor(
-            pd.DataFrame(columns=[str(h) for h in range(1, 33)]),
+            pd.DataFrame(columns=[str(h) for h in mutation_site_headers_actual_3614]),
             num_rows="dynamic",
-            key="manual_any_input"
+            key="manual_32_input"
         )
 
     if not df_32.empty:
-        st.subheader("Binary Labels (Uploaded)")
-        st.dataframe(df_32.style.applymap(lambda v: "background-color: lightgreen" if v == 1 else "background-color: lightcoral"))
-        st.download_button("Download CSV", df_32.to_csv(index=False), "decoded_binary_uploaded.csv", key="download_csv_uploaded")
+        reordered_df_32 = df_32[[str(h) for h in mutation_site_headers_3614 if str(h) in df_32.columns]]
+        st.subheader("Binary Labels (Reordered 4402→3244, 4882→4455)")
+        st.dataframe(reordered_df_32.style.applymap(lambda v: "background-color: lightgreen" if v == 1 else "background-color: lightcoral"))
+        st.download_button("Download Reordered CSV", reordered_df_32.to_csv(index=False), "decoded_binary_32_reordered.csv", key="download_csv_tab5_32_reordered")
 
-        decoded = binary_labels_to_string(df_32.values.flatten().astype(int).tolist())
-        st.subheader("Decoded String")
-        st.write(decoded)
-        st.download_button("Download Concatenated Output", decoded, "decoded_binary_string.txt", key="download_txt_any")
+        decoded_reordered = binary_labels_to_string(reordered_df_32.values.flatten().astype(int).tolist())
+        st.subheader("Decoded String (Reordered 4402→3244, 4882→4455)")
+        st.write(decoded_reordered)
+        st.download_button("Download Concatenated Output", decoded_reordered, "decoded_32bit_string_reordered.txt", key="download_txt_tab5_32")
+
+        df_32_asc = df_32[[str(h) for h in mutation_site_headers_actual_3614 if str(h) in df_32.columns]]
+        st.subheader("Binary Labels (Ascending 3244→4882)")
+        st.dataframe(df_32_asc.style.applymap(lambda v: "background-color: lightgreen" if v == 1 else "background-color: lightcoral"))
+        st.download_button("Download Ascending CSV", df_32_asc.to_csv(index=False), "decoded_binary_32_ascending.csv", key="download_csv_tab5_32_ascend")
 
-        st.subheader("Robot Preparation Script from Binary")
+        decoded_asc = binary_labels_to_string(df_32_asc.values.flatten().astype(int).tolist())
+        st.subheader("Decoded String (Flattened 32-bit Ascending)")
+        st.write(decoded_asc)
+        st.download_button("Download Concatenated Output", decoded_asc, "decoded_32bit_string_ascending.txt", key="download_txt_tab5_32_asc")
+
+        st.subheader("Robot Preparation Script from 32-bit Binary")
 
         df_32_robot = df_32.copy()
         df_32_robot.insert(0, 'Sample', range(1, len(df_32_robot)+1))
@@ -501,24 +662,40 @@ with tab5:
 
         robot_script_32 = []
         source_wells_32 = generate_source_wells(df_32.shape[1])
+        used_destinations = set()
 
         for i, col in enumerate(df_32.columns):
             for row_idx, sample in df_32_robot.iterrows():
                 if int(sample[col]) == 1:
                     source = source_wells_32[i]
                     dest = get_well_position(int(sample['Sample']))
+                    used_destinations.add(dest)
                     vol = round(sample['volume donors (µl)'], 2)
-                    tool = 'TS_10' if vol < 10 else 'TS_50'
-                    robot_script_32.append({
-                        'Source': source,
-                        'Destination': dest,
-                        'Volume': vol,
-                        'Tool': tool
-                    })
-
-        robot_script_32, source_volumes_32 = track_and_replace_source(source_wells_32, robot_script_32)
-
-        d_script, d_volumes = generate_fixed_d_source_instructions_to_all_samples(len(df_32_robot))
+                    if vol > 10:
+                        half_vol = round(vol / 2, 2)
+                        robot_script_32.append({
+                            'Source': source,
+                            'Destination': dest,
+                            'Volume': half_vol,
+                            'Tool': 'TS_10'
+                        })
+                        robot_script_32.append({
+                            'Source': source,
+                            'Destination': dest,
+                            'Volume': vol - half_vol,
+                            'Tool': 'TS_10'
+                        })
+                    else:
+                        robot_script_32.append({
+                            'Source': source,
+                            'Destination': dest,
+                            'Volume': vol,
+                            'Tool': 'TS_10'
+                        })
+
+        robot_script_32, source_volumes_32 = track_and_replace_source(source_wells_32, robot_script_32, volume_limit=volume_limit_input)
+
+        d_script, d_volumes = generate_fixed_d_source_instructions_to_all_samples(len(df_32_robot), volume_limit=volume_limit_input)
         full_robot_script = robot_script_32 + d_script
 
         robot_script_32_df = pd.DataFrame(full_robot_script)
@@ -529,10 +706,10 @@ with tab5:
         robot_script_32_df = robot_script_32_df[['Barcode ID', 'Labware_Source', 'Source', 'Labware_Destination', 'Destination', 'Volume', 'Tool', 'Name']]
 
         st.dataframe(robot_script_32_df)
-        st.download_button("Download Robot Script", robot_script_32_df.to_csv(index=False), "robot_script.csv", key="download_robot_any")
+        st.download_button("Download Robot Script (32-bit)", robot_script_32_df.to_csv(index=False), "robot_script_32bit.csv", key="download_robot_32")
 
         st.subheader("Total Volume Used Per Source")
         combined_volumes = {**source_volumes_32, **d_volumes}
         source_volume_df = pd.DataFrame(list(combined_volumes.items()), columns=['Source', 'Total Volume (µl)'])
         st.dataframe(source_volume_df)
-        st.download_button("Download Source Volumes", source_volume_df.to_csv(index=False), "source_total_volumes.csv", key="download_volume_any")
+        st.download_button("Download Source Volumes", source_volume_df.to_csv(index=False), "source_total_volumes.csv", key="download_volume_32")