Fix tokenizer and format_seq_input to properly handle paired sequences with angle brackets

adapter.py

@@ -215,31 +215,33 @@ class AbLang2PairedHuggingFaceAdapter(AbEncoding, AbRestore, AbAlignment, AbScor
         # Local implementation of format_seq_input
         def format_seq_input(seqs, fragmented=False):
             """Format input sequences for processing."""
+            if isinstance(seqs[0], str):
+                seqs = [seqs]
+            
             if fragmented:
-                # For fragmented sequences, assume they're already in the right format
-                return seqs, 'HL'
-
-            # For paired sequences, format them as VH|VL
-            formatted_seqs = []
-            for seq in seqs:
-                if isinstance(seq, (list, tuple)):
-                    if len(seq) == 2:
-                        # Heavy and light chain
+                # For fragmented sequences, format as VH|VL without angle brackets
+                formatted_seqs = []
+                for seq in seqs:
+                    if isinstance(seq, (list, tuple)) and len(seq) == 2:
                         heavy, light = seq[0], seq[1]
-                        if heavy and light:
-                            formatted_seqs.append(f"{heavy}|{light}")
-                        elif heavy:
-                            formatted_seqs.append(heavy)
-                        elif light:
-                            formatted_seqs.append(light)
-                        else:
-                            formatted_seqs.append("")
+                        formatted_seqs.append(f"{heavy}|{light}")
                     else:
-                        formatted_seqs.append(seq[0] if seq else "")
-                else:
-                    formatted_seqs.append(seq)
-
-            return formatted_seqs, 'HL'
+                        formatted_seqs.append(seq)
+                return formatted_seqs, 'HL'
+            else:
+                # For non-fragmented sequences, add angle brackets: <VH>|<VL>
+                formatted_seqs = []
+                for seq in seqs:
+                    if isinstance(seq, (list, tuple)) and len(seq) == 2:
+                        heavy, light = seq[0], seq[1]
+                        # Add angle brackets and handle empty sequences
+                        heavy_part = f"<{heavy}>" if heavy else "<>"
+                        light_part = f"<{light}>" if light else "<>"
+                        formatted_seqs.append(f"{heavy_part}|{light_part}".replace("<>", ""))
+                    else:
+                        formatted_seqs.append(seq)
+                
+                return formatted_seqs, 'HL'
 
         valid_modes = [
             'rescoding', 'seqcoding', 'restore', 'likelihood', 'probability',

tokenizer_ablang2paired.py

@@ -100,9 +100,16 @@ class AbLang2PairedTokenizer(PreTrainedTokenizer):
         return vocab_files
 
     def __call__(self, sequences, padding=False, return_tensors=None, **kwargs):
-        # Accepts a string or a list of strings
+        # Handle different input formats
         if isinstance(sequences, str):
+            # Single string: "VH|VL"
             sequences = [sequences]
+        elif isinstance(sequences, list) and len(sequences) > 0:
+            if isinstance(sequences[0], list):
+                # List of lists: [['VH', 'VL'], ['VH2', 'VL2']]
+                sequences = [f"{pair[0]}|{pair[1]}" for pair in sequences]
+            # List of strings: ["VH|VL", "VH2|VL2"] - already correct format
+        
         # Tokenize each sequence
         input_ids = [[self._convert_token_to_id(tok) for tok in self._tokenize(seq)] for seq in sequences]
         # Padding