emdbva 0.0.1.dev134__tar.gz → 0.0.1.dev136__tar.gz

{emdbva-0.0.1.dev134/emdbva.egg-info → emdbva-0.0.1.dev136}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: emdbva
-Version: 0.0.1.dev134
+Version: 0.0.1.dev136
 Summary: CryoEM validation toolkit
 Home-page: https://test.pypi.org/project/va/
 Author: Zhe Wang

{emdbva-0.0.1.dev134 → emdbva-0.0.1.dev136/emdbva.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: emdbva
-Version: 0.0.1.dev134
+Version: 0.0.1.dev136
 Summary: CryoEM validation toolkit
 Home-page: https://test.pypi.org/project/va/
 Author: Zhe Wang

{emdbva-0.0.1.dev134 → emdbva-0.0.1.dev136}/va/metrics/bars.py

@@ -147,15 +147,17 @@ def get_resolution_range(new_entry, df, score_type, column='resolution', resbin=
         return None
 
 
-def plot_bar_mat(a, b, qmin, qmax, qscore, work_dir, plot_name, score_type):
+def plot_bar_mat(a, b, qmin, qmax, qscore, work_dir, plot_name, score_type, resbin):
     """
     This function here using matplotlib to produce the Q-score bar image
     """
 
-    a = a*1.5 if a else None
-    b = b*1.5 if b else None
-    a = a/200 if a else None
-    b = b/200 if b else None
+    # Safely scale inputs only when they are provided (allow 0)
+    if a is not None:
+        a = (a * 1.5) / 200.0
+    if b is not None:
+        b = (b * 1.5) / 200.0
+
     # Create a color scale from 0 to 1
     color_scale = np.linspace(0, 1, 199)
 
@@ -173,37 +175,48 @@ def plot_bar_mat(a, b, qmin, qmax, qscore, work_dir, plot_name, score_type):
     diamond_height = 0.65
     diamond_half_width = 0.01
 
-    # Add diamond-shaped marker for 'a'
-    if a != b:
+    # Add diamond-shaped markers depending on availability of a and b
+    if a is not None and b is not None and a != b:
+        # both present and different
         ax.fill(
             [a - diamond_half_width, a, a + diamond_half_width, a],
             [0.5, 0.5 + diamond_height, 0.5, 0.5 - diamond_height],
             color='Black', edgecolor='black'
         )
 
-        # Add diamond-shaped marker for 'b'
         ax.fill(
             [b - diamond_half_width, b, b + diamond_half_width, b],
             [0.5, 0.5 + diamond_height, 0.5, 0.5 - diamond_height],
             facecolor='none', edgecolor='black'
         )
-    else:
-        # ax.fill(
-        #     [b - diamond_half_width, b, b + diamond_half_width, b],
-        #     [0.5, 0.5 + diamond_height, 0.5, 0.5 - diamond_height],
-        #     facecolor='yellow', edgecolor='black'
-        # )
-        top = np.array([[b-diamond_half_width, 0.5], [b, 0.5 + diamond_height], [b + diamond_half_width, 0.5], [b, 0.5]])
-        bottom = np.array([[b-diamond_half_width, 0.5], [b, 0.5], [b + diamond_half_width, 0.5], [b, 0.5 - diamond_height]])
+    elif a is not None and b is not None and a == b:
+        # both present and overlapped
+        top = np.array([[b - diamond_half_width, 0.5], [b, 0.5 + diamond_height], [b + diamond_half_width, 0.5], [b, 0.5]])
+        bottom = np.array([[b - diamond_half_width, 0.5], [b, 0.5], [b + diamond_half_width, 0.5], [b, 0.5 - diamond_height]])
         top_patch = patches.Polygon(top, closed=True, facecolor='black', edgecolor='black')
         bottom_patch = patches.Polygon(bottom, closed=True, facecolor='none', edgecolor='black')
         ax.add_patch(top_patch)
         ax.add_patch(bottom_patch)
+    elif a is not None:
+        # only a present -> solid marker
+        ax.fill(
+            [a - diamond_half_width, a, a + diamond_half_width, a],
+            [0.5, 0.5 + diamond_height, 0.5, 0.5 - diamond_height],
+            color='Black', edgecolor='black'
+        )
+    elif b is not None:
+        # only b present -> hollow marker
+        ax.fill(
+            [b - diamond_half_width, b, b + diamond_half_width, b],
+            [0.5, 0.5 + diamond_height, 0.5, 0.5 - diamond_height],
+            facecolor='none', edgecolor='black'
+        )
+    # else: neither present -> draw no marker
 
-    # add four values as annotationso
+    # add four values as annotations
     worse = r'$\it{Worse}$'
     better = r'$\it{Better}$'
-    ax.annotate(worse, (0, -0.9), color='black', ha='left', fontsize=10, )
+    ax.annotate(worse, (0, -0.9), color='black', ha='left', fontsize=10)
     ax.annotate(better, (1.5, -0.9), color='black', ha='right', fontsize=10)
     ax.annotate(f'{qscore:.3f}', (1.58, 0.2), color='black', ha='center', fontsize=12)
 
@@ -223,32 +236,18 @@ def plot_bar_mat(a, b, qmin, qmax, qscore, work_dir, plot_name, score_type):
     title = plot_name[:-8]
     ax.annotate(title, (0.75, 3.3), color='black', ha='center', fontsize=14, fontweight='bold')
     ax.annotate('Value', (1.58, 1.7), color='black', ha='center', fontsize=14)
-    # if a >= b:
-    #    ax.annotate(f'{a*100/1.5:.2f}%', (a, 1.4), color='black', ha='left', fontsize=10)
-    #    #ax.annotate(f'{b:.2f}', (b, -0.8), color='black', ha='center', fontsize=10)
-    #    #ax.annotate(f'{a*100:.2f}%', (a, 1.4), color='black', ha='center', fontsize=10)
-    #    ax.annotate(f'{b*100/1.5:.2f}%', (b, 1.4), color='black', ha='right', fontsize=10)
-    # else:
-    #    ax.annotate(f'{a*100/1.5:.2f}%', (a, 1.4), color='black', ha='right', fontsize=10)
-    #    #ax.annotate(f'{b:.2f}', (b, -0.8), color='black', ha='center', fontsize=10)
-    #    #ax.annotate(f'{a*100:.2f}%', (a, 1.4), color='black', ha='center', fontsize=10)
-    #    ax.annotate(f'{b*100/1.5:.2f}%', (b, 1.4), color='black', ha='left', fontsize=10)
-
-    # Customize the plot
+
     ax.set_xlim(-0.4, 1.7)
-    # ax.set_ylim(-4.3, 1.8)
-    # to fit the EMD id
     ax.set_ylim(-4.3, 3.6)
     ax.set_yticks([])
 
     ax.spines['top'].set_visible(False)
     ax.spines['right'].set_visible(False)
-    # Remove the left and bottom axis lines (optional)
     ax.spines['left'].set_visible(False)
     ax.spines['bottom'].set_visible(False)
 
-    if a != b:
-        # Add diamond-shaped marker for legend
+    # Legend / explanatory markers: adapt depending on which markers are available
+    if a is not None and b is not None and a != b:
         wa = 0.01
         ha = -2.0
         ax.fill(
@@ -266,11 +265,9 @@ def plot_bar_mat(a, b, qmin, qmax, qscore, work_dir, plot_name, score_type):
             [bha, bha + diamond_height, bha, bha - diamond_height],
             facecolor='none', edgecolor='black'
         )
-        ax.annotate('Percentile relative to EM structures of $\pm$1 $\mathrm{\AA}$ (resolution)',
+        ax.annotate(f'Percentile relative to EM structures of $\\pm${resbin} $\\mathrm{{\\AA}}$ (resolution)',
                     (bwa + 3 * diamond_half_width, bha - 0.25), color='black', ha='left', fontsize=11)
-        # ax.annotate(f'Percentile relative to EM structures of nearest 1000 (resolution)', (bwa + 3*diamond_half_width, bha-0.25), color='black', ha='left', fontsize=11)
-    else:
-        # Add diamond-shaped marker for legend
+    elif a is not None and b is not None and a == b:
         wa = 0.01
         ha = -2.0
         ax.fill(
@@ -280,7 +277,6 @@ def plot_bar_mat(a, b, qmin, qmax, qscore, work_dir, plot_name, score_type):
         )
         ax.annotate('Percentile relative to all EM structures (overlapped)', (wa + 3 * diamond_half_width, ha - 0.25),
                     color='black', ha='left', fontsize=11)
-        # ax.annotate('Percentile relative to all EM structures (overlapped)', (wa + 3*diamond_half_width, ha-0.25), color='black', ha='left', fontsize=11)
 
         bwa = 0.01
         bha = -3.6
@@ -289,9 +285,28 @@ def plot_bar_mat(a, b, qmin, qmax, qscore, work_dir, plot_name, score_type):
             [bha, bha + diamond_height, bha, bha - diamond_height],
             facecolor='none', edgecolor='black'
         )
-        ax.annotate('Percentile relative to EM structures of $\pm$1 $\mathrm{\AA}$ (resolution)',
+        ax.annotate(f'Percentile relative to EM structures of $\\pm${resbin} $\\mathrm{{\\AA}}$ (resolution)',
+                    (bwa + 3 * diamond_half_width, bha - 0.25), color='black', ha='left', fontsize=11)
+    elif a is not None:
+        wa = 0.01
+        ha = -2.0
+        ax.fill(
+            [wa - diamond_half_width, wa, wa + diamond_half_width, wa],
+            [ha, ha + diamond_height, ha, ha - diamond_height],
+            color='black', edgecolor='black'
+        )
+        ax.annotate('Percentile relative to all EM structures', (wa + 3 * diamond_half_width, ha - 0.25),
+                    color='black', ha='left', fontsize=11)
+    elif b is not None:
+        bwa = 0.01
+        bha = -3.6
+        ax.fill(
+            [bwa - diamond_half_width, bwa, bwa + diamond_half_width, bwa],
+            [bha, bha + diamond_height, bha, bha - diamond_height],
+            facecolor='none', edgecolor='black'
+        )
+        ax.annotate(f'Percentile relative to EM structures of $\\pm${resbin} $\\mathrm{{\\AA}}$ (resolution)',
                     (bwa + 3 * diamond_half_width, bha - 0.25), color='black', ha='left', fontsize=11)
-        # ax.annotate(f'Percentile relative to EM structures of nearest 1000 (resolution)', (bwa + 3*diamond_half_width, bha-0.25), color='black', ha='left', fontsize=11)
 
     ax.tick_params(axis='both', which='both', length=0)
     plt.gca().set_xticklabels([])
@@ -302,16 +317,23 @@ def plot_bar_mat(a, b, qmin, qmax, qscore, work_dir, plot_name, score_type):
 
 
 def bar(new_entry_dict, score_type, work_dir, score_dir, plot_name, update_bin_file=None):
-    input_file = '{}/qscores.csv'.format(score_dir)
-    print(f'The all Q-score file is: {input_file}.')
-    resbin = current_qscore_resolution_bin(input_file, update_bin_file)
-    print(f'Current resolution bin size for Q_relative is: {resbin}.')
+    if update_bin_file and os.path.isfile(update_bin_file):
+        input_file = update_bin_file
+    else:
+        candidate = os.path.join(score_dir, 'qscores.csv')
+        if os.path.isfile(candidate):
+            input_file = candidate
+        else:
+            raise ValueError('All Qscore file does not exist to produce the slider.')
+    print(f'The all {score_type} file is: {input_file}.')
+    resbin = current_qscore_resolution_bin(input_file, update_bin_file, work_dir)
+    print(f'Current resolution bin size for {score_type} is: {resbin}.')
 
     # new_entry_dict = {'id': '8117', 'resolution': 2.95, 'name': '5irx.cif', 'qscore': 0.521}
     qmin = None
     qmax = None
     df = load_score(input_file, new_entry_dict, score_type)
-    if score_type and new_entry_dict[score_type]:
+    if score_type and score_type in new_entry_dict and not pd.isna(new_entry_dict[score_type]):
         (qmin, qmax), original_value = get_score(df, new_entry_dict[score_type], score_type)
         target_value = int(match_to_newscale((0, sum(original_value)), (0, 199), original_value[0]))
         to_whole = round(target_value/200., 3)
@@ -326,7 +348,6 @@ def bar(new_entry_dict, score_type, work_dir, score_dir, plot_name, update_bin_f
         whole_res_low = None
         whole_res_hight = None
 
-    #df1000 = get_nearest_onethousand(new_entry_dict, df, 500, score_type)
     if new_entry_dict['resolution']:
         df1000 = get_resolution_range(new_entry_dict, df, score_type, 'resolution', resbin)
         (sqmin, sqmax), ovalue = get_score(df1000, new_entry_dict[score_type], score_type)
@@ -343,8 +364,8 @@ def bar(new_entry_dict, score_type, work_dir, score_dir, plot_name, update_bin_f
         relative_res_low = None
         relative_res_high = None
 
-    if to_whole and to_two:
-        plot_bar_mat(target_value, target_value_two, qmin, qmax, new_entry_dict[score_type], work_dir, plot_name, score_type)
+    if to_whole is not None and to_two is not None:
+        plot_bar_mat(target_value, target_value_two, qmin, qmax, new_entry_dict[score_type], work_dir, plot_name, score_type, resbin)
     print(f'{score_type} to whole: {to_whole_real}, to relative resolution: {to_two_real}')
 
     return  ((to_whole_real, to_whole_counts, whole_res_low, whole_res_hight), (to_two_real, to_two_counts, relative_res_low, relative_res_high), resbin)
@@ -408,18 +429,32 @@ def resolution_qrelative_correlation(df_resolution_sorted, values, score_type='q
     correlation_below_5 = []
     correlation_above_5 = []
     col_names = []
-    for i, value in enumerate(values):
-        if score_type == 'qscore':
-            col_name = f'q_relative_{value}'  # Dynamically create the column name
-        # Filter the data for resolution < 5 Å and > 5 Å
+    for value in values:
+        col_name = f'q_relative_{value}' if score_type == 'qscore' else f'q_relative_{value}'
+        # Filter the data for resolution <= 5 Å and > 5 Å
         data_below_5 = df_resolution_sorted[df_resolution_sorted['resolution'] <= 5]
         data_above_5 = df_resolution_sorted[df_resolution_sorted['resolution'] > 5]
 
-        # Calculate correlation for resolution <= 5 Å
-        corr_below_5, _ = scipy.stats.pearsonr(data_below_5['resolution'], data_below_5[col_name])
+        # If the column doesn't exist, record NaN and continue
+        if col_name not in df_resolution_sorted.columns:
+            correlation_below_5.append(np.nan)
+            correlation_above_5.append(np.nan)
+            col_names.append(col_name)
+            continue
+
+        def safe_pearson(x, y):
+            # Require at least 2 samples
+            if x.size < 2 or y.size < 2:
+                return np.nan
+            try:
+                corr, _ = scipy.stats.pearsonr(x, y)
+            except Exception:
+                return np.nan
+            return corr
+
+        corr_below_5 = safe_pearson(data_below_5['resolution'].to_numpy(), data_below_5[col_name].to_numpy())
+        corr_above_5 = safe_pearson(data_above_5['resolution'].to_numpy(), data_above_5[col_name].to_numpy())
 
-        # Calculate correlation for resolution > 5 Å
-        corr_above_5, _ = scipy.stats.pearsonr(data_above_5['resolution'], data_above_5[col_name])
         correlation_below_5.append(corr_below_5)
         correlation_above_5.append(corr_above_5)
         col_names.append(col_name)
@@ -435,7 +470,7 @@ def get_resolution_bin_size_fromva(score_file):
 
     return float(current_qscore_resolution_bin)
 
-def get_resolution_bin_size_fromfile(input_score_file, score_type='qscore'):
+def get_resolution_bin_size_fromfile(input_score_file, work_dir=None, score_type='qscore'):
     """
         Get the resolution bin size from the input score file
     """
@@ -453,12 +488,40 @@ def get_resolution_bin_size_fromfile(input_score_file, score_type='qscore'):
     values = [round(x, 1) for x in np.arange(0.1, 1.6, 0.1)]
     correlatioin_below_5, correlation_above_5, col_names = resolution_qrelative_correlation(df_resolution_sorted,
                                                                                             values, score_type='qscore')
+    print('Correlation above 5A:', correlation_above_5)
+    print('Correlation below 5A:', correlatioin_below_5)
+    print('Column names:', col_names)
+    # create and save a two-curve plot for the correlations
+    try:
+        xs = [float(c.replace('q_relative_', '')) for c in col_names]
+    except Exception:
+        xs = list(range(len(col_names)))
+    idx = np.argsort(xs)
+    xs_sorted = np.array(xs)[idx]
+    y_above = np.array(correlation_above_5, dtype=float)[idx]
+    y_below = np.array(correlatioin_below_5, dtype=float)[idx]
+
+    plt.figure(figsize=(7, 4), dpi=150)
+    plt.plot(xs_sorted, y_above, marker='o', linestyle='-', label='Correlation above 5 Å')
+    plt.plot(xs_sorted, y_below, marker='s', linestyle='--', label='Correlation below 5 Å')
+    plt.xlabel('Resolution bin size')
+    plt.ylabel('Pearson correlation')
+    plt.title('Resolution vs Q_relative correlation')
+    plt.legend()
+    plt.grid(alpha=0.4, linestyle='--')
+    out_fname = f'{work_dir}/bin_size_resolution_correlation.png'
+    plt.tight_layout()
+    plt.savefig(out_fname)
+    plt.close()
+    print(f'Correlation plot saved to {os.path.abspath(out_fname)}')
+    # saved cur
+
     optimal_index = find_optimal_correlation_index(correlatioin_below_5)
     optimal_resolution_bin = col_names[optimal_index].replace('q_relative_', '') if optimal_index is not None else None
 
     return float(optimal_resolution_bin)
 
-def current_qscore_resolution_bin(score_file, update_resolution_bin_file=None):
+def current_qscore_resolution_bin(score_file, update_resolution_bin_file=None, work_dir=None):
     """
     Calculate the Q-score resolution bin based on the current all qscore in csv.
     """
@@ -481,7 +544,7 @@ def current_qscore_resolution_bin(score_file, update_resolution_bin_file=None):
     resolution_bin_size = cfg.get('resolution_bin_size')
 
     if update_resolution_bin_file is not None:
-        resolution_bin_size = get_resolution_bin_size_fromfile(update_resolution_bin_file)
+        resolution_bin_size = get_resolution_bin_size_fromfile(update_resolution_bin_file, work_dir)
         save_and_log(cfg, resolution_bin_size, update_resolution_bin_file)
         return resolution_bin_size
 
@@ -490,9 +553,6 @@ def current_qscore_resolution_bin(score_file, update_resolution_bin_file=None):
         return resolution_bin_size
 
     print('No resolution bin size found in config file, will calculate from score file.')
-    resolution_bin_size = get_resolution_bin_size_fromfile(score_file)
+    resolution_bin_size = get_resolution_bin_size_fromfile(score_file, work_dir)
     save_and_log(cfg, resolution_bin_size, score_file)
     return resolution_bin_size
-
-
-

{emdbva-0.0.1.dev134 → emdbva-0.0.1.dev136}/va/metrics/phaserandomization.py

@@ -183,8 +183,8 @@ def calculate_pixels(angpix):
     """
 
     if angpix != 0:
-        dilatepx = 10 * angpix
-        softpx = 5 * angpix
+        dilatepx = 3
+        softpx = 8
         return dilatepx, softpx
     else:
         print('No hard and soft radius for mask as voxel value is 0.')
@@ -196,7 +196,7 @@ def relion_auto_mask_fast(data, threshold, extend_pixels, edge_width, verbose=Tr
     steps = []
     if verbose:
         steps = tqdm(total=3, desc="Masking Steps", unit="step")
-
+ 
     # Step 1: Initial binary mask
     mask = (data >= threshold).astype(np.float32)
     if verbose:

{emdbva-0.0.1.dev134 → emdbva-0.0.1.dev136}/va/metrics/projections.py

@@ -8,6 +8,7 @@ import numpy as np
 from math import ceil
 from scipy import ndimage
 from mrcfile.mrcfile import MrcFile
+from PIL import Image
 import inspect
 from va.utils.misc import out_json
 
@@ -179,6 +180,60 @@ class Projections:
 
         return ind, org, scale
 
+    def _green_percentage(self, image_obj):
+        """
+        image_obj can be a file path, PIL Image, or numpy array.
+        Returns a dictionary with:
+          - percentage: total green percentage in the whole image
+          - diff_vertical: left-half green percentage minus right-half green percentage
+          - diff_horizontal: top-half green percentage minus bottom-half green percentage
+        """
+        if isinstance(image_obj, str):
+            img = Image.open(image_obj).convert("RGB")
+        elif isinstance(image_obj, Image.Image):
+            img = image_obj.convert("RGB")
+        else:
+            img = Image.fromarray(image_obj).convert("RGB")
+
+        img_array = np.array(img)
+        green_mask = np.all(img_array == [0, 138, 0], axis=-1)
+        height, width = green_mask.shape
+        total_pixels = height * width
+        if total_pixels == 0:
+            return {
+                'percentage': 0.0,
+                'diff_vertical': 0.0,
+                'diff_horizontal': 0.0,
+            }
+
+        green_pixels = np.sum(green_mask)
+        proportion_green = (green_pixels / total_pixels) * 100
+
+        mid_vertical = width // 2
+        left_total = height * mid_vertical
+        right_total = height * (width - mid_vertical)
+        green_pixels_left_half = np.sum(green_mask[:, :mid_vertical])
+        green_pixels_right_half = np.sum(green_mask[:, mid_vertical:])
+        proportion_green_left_half = (green_pixels_left_half / left_total) * 100 if left_total else 0.0
+        proportion_green_right_half = (green_pixels_right_half / right_total) * 100 if right_total else 0.0
+        diff_vertical = proportion_green_left_half - proportion_green_right_half
+
+        mid_horizontal = height // 2
+        top_total = mid_horizontal * width
+        bottom_total = (height - mid_horizontal) * width
+        green_pixels_top_half = np.sum(green_mask[:mid_horizontal, :])
+        green_pixels_bottom_half = np.sum(green_mask[mid_horizontal:, :])
+        proportion_green_top_half = (green_pixels_top_half / top_total) * 100 if top_total else 0.0
+        proportion_green_bottom_half = (green_pixels_bottom_half / bottom_total) * 100 if bottom_total else 0.0
+        diff_horizontal = proportion_green_top_half - proportion_green_bottom_half
+
+        return {
+            'percentage': round(proportion_green, 2),
+            'diff_vertical': round(diff_vertical, 2),
+            'diff_horizontal': round(diff_horizontal, 2),
+        }
+
+
     def orthogonal_projections(self, mapin=None, workdir=None, type=None, label=''):
         map, workdir = self.mapincheck(mapin, workdir)
         if map is not None and workdir is not None:
@@ -202,6 +257,7 @@ class Projections:
                 glow_scale_result = {}
                 glow_org_final = {}
                 glow_scale_final = {}
+                green_result = {}
                 for axis in range(2, -1, -1):
                     ind, org, scale = self.map_to_img(map, axis, type, self.errlist)
                     org_result.update(org)
@@ -212,6 +268,10 @@ class Projections:
                         glow_ind, glow_org, glow_scale = self.map_to_img(map, axis, type, self.errlist, self.glowimage)
                         glow_org_result.update(glow_org)
                         glow_scale_result.update(glow_scale)
+                        if type == 'std':
+                            for axis_name, image_obj in glow_org.items():
+                                green_result[axis_name] = self._green_percentage(f'{workdir}/{image_obj}')
+
                         # if type == 'central' or type == 'largestvariance':
                         #     glow_ind_result.update(glow_ind)
                     # if type == 'central' or type == 'largestvariance':
@@ -231,7 +291,10 @@ class Projections:
                     result_dict[f'{label}central_slice'] = {**final_org, **final_scale, **final_ind}
                 elif type == 'max' or type == 'projection' or type == 'std':
                     if glow_org_final and glow_scale_final:
-                        result_dict[f'{label}orthogonal_glow_{type}'] = {**glow_org_final, **glow_scale_final}
+                        glow_entry = {**glow_org_final, **glow_scale_final}
+                        if green_result:
+                            glow_entry['green_percentage'] = green_result
+                        result_dict[f'{label}orthogonal_glow_{type}'] = glow_entry
                     result_dict[f'{label}orthogonal_{type}'] = {**final_org, **final_scale}
                 else:
                     result_dict[f'{label}orthogonal_{type}'] = {**final_org, **final_scale}

{emdbva-0.0.1.dev134 → emdbva-0.0.1.dev136}/va/preparation.py

@@ -1367,7 +1367,11 @@ class PreParation:
 
         auth_comp_id_map = {}
         for chain, resseq, auth_comp_id in zip(chains, resseqs, auth_comp_ids):
-            key = (chain, int(resseq))
+            try:
+                resseq_key = int(resseq)
+            except ValueError:
+                resseq_key = resseq
+            key = (chain, resseq_key)
             auth_comp_id_map[key] = auth_comp_id
 
         return auth_comp_id_map
@@ -1391,7 +1395,11 @@ class PreParation:
 
         formal_charge_map = {}
         for chain, resseq, formal_charge in zip(chains, resseqs, formal_charges):
-            key = (chain, int(resseq))
+            try:
+                resseq_key = int(resseq)
+            except ValueError:
+                resseq_key = resseq
+            key = (chain, resseq_key)
             formal_charge_map[key] = formal_charge
 
         return formal_charge_map
@@ -1432,8 +1440,13 @@ class PreParation:
 
         # Add auth_comp_id based on the map
         for res, chain, resseq in zip(residues, chains, resseqs):
-            auth_comp_id = auth_comp_id_map.get((chain, int(resseq)), res)
-            formal_charge = formal_charge_map.get((chain, int(resseq)), '?')
+            try:
+                resseq_key = int(resseq)
+            except ValueError:
+                resseq_key = resseq
+            key = (chain, resseq_key)
+            auth_comp_id = auth_comp_id_map.get(key, res)
+            formal_charge = formal_charge_map.get(key, '?')
             mmcif_dict['_atom_site.auth_comp_id'].append(auth_comp_id)
             mmcif_dict['_atom_site.pdbx_formal_charge'].append(formal_charge)
 

{emdbva-0.0.1.dev134 → emdbva-0.0.1.dev136}/va/version.py

@@ -18,5 +18,5 @@ under the License.
 
 """
 
-__version__ = '0.0.1.dev134'
+__version__ = '0.0.1.dev136'
 __em_statistics_version__ = '202505.v01'