BUG: tabulate-seqs shows every taxonomy in the collection and respects merge_method (#371)

# Description
<!-- REQUIRED: Briefly describe this PR, or link the issue it closes.
-->

Since the refactor in #369, tabulate-seqs rendered only the first member
of the --i-taxonomy collection, and it built rows from every sequence
regardless of --p-merge-method (only the length statistics used the
merged set). Each taxonomy now gets its own Taxon/Confidence columns,
prefixed with its collection key when keys are given ('gtdb Taxon',
'silva Taxon'); unkeyed collections keep plain headers for one taxonomy
and are numbered ('Taxonomy 1 Taxon', ...) for several. Rows are limited
to the features selected by merge_method.

Found by @gregcaporaso while comparing GTDB and SILVA taxonomies of the
gut-to-soil ASVs; he asked for the fix on a branch. Claude wrote the
change and the six new tests, which read the table JSON embedded in
index.html (the existing tests check page text and did not catch either
regression). 

This also led to the finding and fixing (by @Oddant1) of rachis-org/rachis#974. 

# AI Disclosure
<!-- REQUIRED: Check exactly one option. -->

- [ ] NO AI USED.
- [X] AI USED.


# AI Usage Details
AI detected this issue through some work that I was doing that utilized
this. Code, commit message, and tests initially written by Claude.

---------

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
Co-authored-by: Anthony Simard <als872@nau.edu>
Co-authored-by: Oddant1 <oddant1@hotmail.com>

Author: 3 people

q2_feature_table/_summarize/_visualizer.py

@@ -101,12 +101,27 @@ def tabulate_seqs(
     seq_df = pd.DataFrame.from_dict(sequences, orient='index')
     if taxonomy is not None:
         if isinstance(taxonomy, pd.DataFrame):
-            seq_df = pd.concat([seq_df, taxonomy], axis=1)
-        else:
-            taxonomy = next(iter(taxonomy.values()))
-            seq_df = pd.concat([seq_df, taxonomy], axis=1)
+            taxonomy = {'0': taxonomy}
+        keys = list(taxonomy)
+        # unlabelled collections are keyed '0', '1', ... by the framework
+        labelled = keys != [str(i) for i in range(len(keys))]
+        for key, member in taxonomy.items():
+            # 'Taxon: gtdb'; unlabelled: plain for one, 'Taxon: 1', ... for
+            # several
+            if labelled:
+                label = key
+            elif len(keys) > 1:
+                label = str(int(key) + 1)
+            else:
+                label = None
+
+            if label is not None:
+                member = member.rename(columns=lambda c: f'{c}: {label}')
+            seq_df = pd.concat([seq_df, member], axis=1)
     if metadata is not None:
         seq_df = pd.concat([seq_df, metadata_df], axis=1)
+    # show only the features selected by merge_method
+    seq_df = seq_df.loc[[i for i in seq_df.index if i in display_sequences]]
     seq_df.index.name = 'Feature ID'
     seq_df = seq_df[
         [col for col in seq_df.columns if col != 'seq'] + ['seq']

q2_feature_table/tests/test_summarize.py

@@ -468,6 +468,109 @@ def test_optional_input_strict_fail(self):
                               taxonomy=taxonomy)
                 # Did not error out, this is a problem
 
+    def _rendered_table(self, output_dir):
+        with open(os.path.join(output_dir, 'index.html')) as fh:
+            html = fh.read()
+        data = re.search(
+            r'<script id="data" type="application/json">(.*?)</script>',
+            html, re.S).group(1)
+        table = json.loads(data)
+        columns = [c[0] for c in table['columns']]
+        rows = {r[columns.index('Feature ID')]: dict(zip(columns, r))
+                for r in table['data']}
+        return columns, rows
+
+    def _seqs_and_taxonomies(self):
+        seqs = DNAIterator(skbio.DNA(a, metadata=b) for a, b in (
+            ('ACGT', {'id': 'seq1'}),
+            ('AAAA', {'id': 'seq2'}),
+            ('CCCC', {'id': 'seq3'})))
+        index = ['seq1', 'seq2', 'seq3']
+        tax1 = pd.DataFrame([('a;b;c', '0.9'), ('a;b;d', '0.8'),
+                             ('a;e', '0.7')],
+                            index=index, columns=['Taxon', 'Confidence'])
+        tax2 = pd.DataFrame([('x;y;z', '1.0'), ('x;y;w', '0.6'),
+                             ('x', '0.5')],
+                            index=index, columns=['Taxon', 'Confidence'])
+        return seqs, tax1, tax2
+
+    def test_multiple_taxonomies_labelled(self):
+        seqs, tax1, tax2 = self._seqs_and_taxonomies()
+        with tempfile.TemporaryDirectory() as output_dir:
+            tabulate_seqs(output_dir, seqs,
+                          taxonomy={'gtdb': tax1, 'silva': tax2})
+            columns, rows = self._rendered_table(output_dir)
+        for col in ('Taxon: gtdb', 'Confidence: gtdb',
+                    'Taxon: silva', 'Confidence: silva'):
+            self.assertIn(col, columns)
+        self.assertNotIn('Taxon', columns)
+        self.assertEqual(rows['seq2']['Taxon: gtdb'], 'a;b;d')
+        self.assertEqual(rows['seq2']['Taxon: silva'], 'x;y;w')
+
+    def test_multiple_taxonomies_unlabelled(self):
+        seqs, tax1, tax2 = self._seqs_and_taxonomies()
+        with tempfile.TemporaryDirectory() as output_dir:
+            tabulate_seqs(output_dir, seqs, taxonomy={'0': tax1, '1': tax2})
+            columns, rows = self._rendered_table(output_dir)
+        self.assertIn('Taxon: 1', columns)
+        self.assertIn('Taxon: 2', columns)
+        self.assertEqual(rows['seq3']['Taxon: 1'], 'a;e')
+        self.assertEqual(rows['seq3']['Taxon: 2'], 'x')
+
+    def test_single_taxonomy_labelled(self):
+        seqs, tax1, _ = self._seqs_and_taxonomies()
+        with tempfile.TemporaryDirectory() as output_dir:
+            tabulate_seqs(output_dir, seqs, taxonomy={'gtdb': tax1})
+            columns, rows = self._rendered_table(output_dir)
+        self.assertIn('Taxon: gtdb', columns)
+        self.assertNotIn('Taxon', columns)
+        self.assertEqual(rows['seq1']['Taxon: gtdb'], 'a;b;c')
+
+    def test_single_taxonomy_unlabelled(self):
+        seqs, tax1, _ = self._seqs_and_taxonomies()
+        with tempfile.TemporaryDirectory() as output_dir:
+            tabulate_seqs(output_dir, seqs, taxonomy={'0': tax1})
+            columns, rows = self._rendered_table(output_dir)
+        self.assertIn('Taxon', columns)
+        self.assertIn('Confidence', columns)
+        self.assertEqual(rows['seq1']['Taxon'], 'a;b;c')
+
+    def test_single_taxonomy_unlabelled_result_collection(self):
+        # the action receives a ResultCollection, whose iteration differs
+        # from a dict's
+        seqs, tax1, _ = self._seqs_and_taxonomies()
+        with tempfile.TemporaryDirectory() as output_dir:
+            tabulate_seqs(output_dir, seqs,
+                          taxonomy=qiime2.ResultCollection({'0': tax1}))
+            columns, rows = self._rendered_table(output_dir)
+        self.assertIn('Taxon', columns)
+        self.assertNotIn('Taxon: 0', columns)
+        self.assertEqual(rows['seq1']['Taxon'], 'a;b;c')
+
+    def test_rows_intersect(self):
+        seqs, tax1, tax2 = self._seqs_and_taxonomies()
+        metadata = qiime2.Metadata(pd.DataFrame(
+            {'frequency': [10.0, 20.0]},
+            index=pd.Index(['seq1', 'seq3'], name='feature id')))
+        with tempfile.TemporaryDirectory() as output_dir:
+            tabulate_seqs(output_dir, seqs, metadata=metadata,
+                          taxonomy={'gtdb': tax1, 'silva': tax2},
+                          merge_method='intersect')
+            _, rows = self._rendered_table(output_dir)
+        self.assertEqual(set(rows), {'seq1', 'seq3'})
+        self.assertEqual(rows['seq3']['frequency'], 20.0)
+
+    def test_rows_union(self):
+        seqs, tax1, _ = self._seqs_and_taxonomies()
+        metadata = qiime2.Metadata(pd.DataFrame(
+            {'frequency': [10.0, 30.0]},
+            index=pd.Index(['seq1', 'seq4'], name='feature id')))
+        with tempfile.TemporaryDirectory() as output_dir:
+            tabulate_seqs(output_dir, seqs, metadata=metadata,
+                          taxonomy={'gtdb': tax1}, merge_method='union')
+            _, rows = self._rendered_table(output_dir)
+        self.assertEqual(set(rows), {'seq1', 'seq2', 'seq3', 'seq4'})
+
 
 class _SummarizeTests(TestCase):
     def test_basic(self):