@lark-apaas/coding-steering 0.1.18-dev.ec88bb5 → 0.1.18-dev.fb5e270

package/steering/design-html/skills/pptx-style-extract/scripts/test_layout_css.py

@@ -0,0 +1,503 @@
+#!/usr/bin/env python3
+"""Regression tests for the consumer-facing layout slot CSS contract."""
+import os
+import sys
+import tempfile
+import unittest
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+
+from check_v2 import Pack, rule_v2_16  # noqa: E402
+from draft import (attach_leftover_image_marks, contact_sheets, draft_layouts,  # noqa: E402
+                   emit_layouts, emit_manifest, fullscreen_overlay_media,
+                   has_small_image_cluster, needs_asset_judgment,
+                   slide_image_marks, slot_style)
+from package import (FONTSIZE_RE, Fail, apply_asset_decisions,  # noqa: E402
+                     build_layouts_md, resolve_asset_candidate_lines,
+                     split_top_blocks)
+
+
+class LayoutCssTest(unittest.TestCase):
+    def test_text_slot_emits_rendering_style_as_css_only(self):
+        shape = {
+            'text': {
+                'bodyPr': {
+                    'anchor': 'ctr',
+                    'insets_px': {'lIns': 12, 'tIns': 8, 'rIns': 10, 'bIns': 6},
+                    'rot': '900000',
+                },
+                'lstStyle': {
+                    'lvl1pPr': {
+                        'sz_px': 48,
+                        'weight': 600,
+                        'italic': True,
+                        'underline': 'sng',
+                        'strike': 'sngStrike',
+                        'spc_px': 1.5,
+                        'color': {'resolved': '#123456'},
+                        'algn': 'ctr',
+                        'lnSpc': {'mult': 1.0},
+                    },
+                },
+                'paragraphs': [],
+            },
+        }
+        slot = {
+            'role': 'title',
+            'type': 'title',
+            'box': [100, 80, 800, 160],
+            'sz': 48,
+            'txt': '标题',
+        }
+        slot.update(slot_style(shape))
+        archetype = {
+            'name': 'layout-1',
+            'zh': '标题页',
+            'role': 'content',
+            'bg': None,
+            'slots': [slot],
+            'decor': [],
+            'pages': [1],
+            'rep': 1,
+            'pic_n': 0,
+            'confidence': 'high',
+        }
+
+        with tempfile.TemporaryDirectory() as output_dir:
+            emit_layouts([archetype], output_dir)
+            with open(os.path.join(output_dir, 'layouts.yaml'), encoding='utf-8') as stream:
+                layouts_yaml = stream.read()
+            layouts_md = build_layouts_md(split_top_blocks(layouts_yaml), (1920, 1080))
+
+        self.assertIn(
+            'css: "box-sizing: border-box; padding: 8px 10px 6px 12px; '
+            'font-size: 48px; font-weight: 600; font-style: italic; '
+            'text-decoration: underline line-through; letter-spacing: 1.5px; color: #123456; '
+            'text-align: center; line-height: 1.2; display: flex; '
+            'flex-direction: column; justify-content: center; rotate: 15deg"',
+            layouts_md,
+        )
+        for legacy_key in ('size', 'weight', 'color', 'align', 'valign', 'insets_px'):
+            self.assertNotRegex(layouts_md, rf'[,{{]\s*{legacy_key}:')
+        self.assertEqual(FONTSIZE_RE.findall(layouts_md), ['48'])
+
+    def test_layout_gate_rejects_legacy_slot_style_keys(self):
+        with tempfile.TemporaryDirectory() as pack_dir:
+            with open(os.path.join(pack_dir, 'design.md'), 'w', encoding='utf-8') as stream:
+                stream.write('---\nversion: alpha\nlayouts: layouts.md\n---\n\nRead layouts.md.\n')
+            with open(os.path.join(pack_dir, 'layouts.md'), 'w', encoding='utf-8') as stream:
+                stream.write(
+                    '---\ncanvas: 1920x1080\nlayouts:\n  cover:\n    role: cover\n'
+                    '    slots:\n      - {role: title, type: title, box: [0, 0, 800, 100], '
+                    'size: 48, align: center}\n    confidence: high\n---\n'
+                )
+
+            result = rule_v2_16(Pack(pack_dir))
+
+        self.assertEqual(result.level, 'FAIL')
+        self.assertEqual(len(result.fails), 1)
+        self.assertIn('旧样式键 align/size', result.fails[0])
+
+    def test_normautofit_fontscale_shrinks_emitted_font_size(self):
+        # 章节大号数字：160px 字号靠 normAutofit fontScale 0.9 装进 144px 的框。
+        # 不乘 fontScale，消费端拿到 160px，字比框高，渐变裁切把底部切成透明。
+        shape = {
+            'text': {
+                'bodyPr': {'anchor': 't', 'font_scale': 0.9, 'ln_spc_reduction': 0.1},
+                'lstStyle': {'lvl1pPr': {'sz_px': 160, 'lnSpc': {'mult': 1.0}}},
+                'paragraphs': [{'runs': [{'text': '01.'}]}],
+            },
+        }
+        style = slot_style(shape)
+        self.assertIn('font-size: 144px', style['css'])
+        self.assertNotIn('font-size: 160px', style['css'])
+        # lnSpcReduction 0.1 把 1.0*1.2 的行高压到 1.08
+        self.assertIn('line-height: 1.08', style['css'])
+
+    def test_missing_autofit_leaves_font_size_untouched(self):
+        # 无 normAutofit（或无 fontScale）时零影响：字号原样、行高不缩。
+        shape = {
+            'text': {
+                'bodyPr': {'anchor': 't'},
+                'lstStyle': {'lvl1pPr': {'sz_px': 160, 'lnSpc': {'mult': 1.0}}},
+                'paragraphs': [{'runs': [{'text': '01.'}]}],
+            },
+        }
+        style = slot_style(shape)
+        self.assertIn('font-size: 160px', style['css'])
+        self.assertIn('line-height: 1.2', style['css'])
+
+    def test_run_level_style_is_emitted_from_flat_ooxml_record(self):
+        # read_txbody 把 a:rPr 的属性直接展开到 run；没有嵌套 rPr 字段。
+        shape = {
+            'text': {
+                'bodyPr': {'anchor': 't'},
+                'paragraphs': [{
+                    'runs': [{
+                        'text': '品牌标题',
+                        'sz_px': 52,
+                        'weight': 700,
+                        'latin': 'Brand Sans',
+                        'color': {'resolved': '#C1121F'},
+                    }],
+                }],
+            },
+        }
+
+        style = slot_style(shape)
+
+        self.assertIn('font-size: 52px', style['css'])
+        self.assertIn(
+            'font-family: "Brand Sans", "PingFang SC", "Microsoft YaHei", sans-serif',
+            style['css'],
+        )
+        self.assertIn('font-weight: 700', style['css'])
+        self.assertIn('color: #C1121F', style['css'])
+
+    def test_run_level_style_overrides_inherited_list_style(self):
+        shape = {
+            'text': {
+                'lstStyle': {
+                    'lvl1pPr': {
+                        'sz_px': 20,
+                        'latin': 'Inherited Sans',
+                        'color': {'resolved': '#111111'},
+                    },
+                },
+                'paragraphs': [{
+                    'runs': [{
+                        'text': '直接格式',
+                        'sz_px': 52,
+                        'latin': 'Direct Sans',
+                        'color': {'resolved': '#C1121F'},
+                    }],
+                }],
+            },
+        }
+
+        style = slot_style(shape)
+
+        self.assertIn('font-size: 52px', style['css'])
+        self.assertIn('font-family: "Direct Sans"', style['css'])
+        self.assertIn('color: #C1121F', style['css'])
+        self.assertNotIn('font-size: 20px', style['css'])
+        self.assertNotIn('Inherited Sans', style['css'])
+
+    def test_asset_decisions_keep_content_slots_and_bind_texture_slots(self):
+        manifest = {
+            'assets': [],
+            'asset_decisions': [
+                {'source_media': 'chart.png', 'decision': 'content'},
+                {'source_media': 'ornament.png', 'decision': 'texture'},
+            ],
+        }
+
+        decisions, asset_ids = apply_asset_decisions(manifest)
+        lines = resolve_asset_candidate_lines([
+            '      - {role: asset-candidate, box: [10, 20, 300, 200], type: pic, '
+            'source_media: chart.png}',
+            '      - {role: asset-candidate, box: [20, 30, 80, 80], type: pic, '
+            'source_media: ornament.png}',
+        ], decisions, asset_ids)
+
+        self.assertEqual(len(lines), 2)
+        self.assertNotIn('chart.png', lines[0])
+        self.assertNotIn('source_media', lines[0])
+        self.assertNotIn('asset:', lines[0])
+        self.assertIn('role: pic', lines[0])
+        self.assertNotIn('source_media', lines[1])
+        self.assertIn('role: texture', lines[1])
+        self.assertIn('asset: texture-1', lines[1])
+        self.assertEqual(manifest['assets'], [{
+            'id': 'texture-1',
+            'source_media': 'ornament.png',
+            'kind': 'texture',
+        }])
+
+    def test_asset_decisions_do_not_reuse_an_existing_asset_id(self):
+        manifest = {
+            'assets': [
+                {
+                    'id': 'logo-primary',
+                    'source_media': 'candidate.png',
+                    'kind': 'logo',
+                },
+                {
+                    'id': 'texture-1',
+                    'source_media': 'existing.png',
+                    'kind': 'texture',
+                },
+            ],
+            'asset_decisions': [
+                {'source_media': 'candidate.png', 'decision': 'texture'},
+            ],
+        }
+
+        _, asset_ids = apply_asset_decisions(manifest)
+
+        self.assertEqual(asset_ids['existing.png'], 'texture-1')
+        self.assertEqual(asset_ids['candidate.png'], 'texture-2')
+        self.assertEqual(
+            [asset['id'] for asset in manifest['assets']],
+            ['texture-2', 'texture-1'],
+        )
+
+    def test_asset_decisions_reject_candidates_without_layout_slots(self):
+        manifest = {
+            'assets': [],
+            'asset_decisions': [
+                {'source_media': 'orphan-decoration.png', 'decision': 'texture'},
+            ],
+        }
+
+        with self.assertRaisesRegex(Fail, '没有对应图片槽'):
+            apply_asset_decisions(manifest, bound_sources=set())
+
+    def test_translucent_fullscreen_decoration_requires_model_judgment(self):
+        candidate = {
+            'file': 'glow.png',
+            'fullscreen': True,
+            'slides': [2],
+            'probe': {'alpha_mean': 80},
+        }
+
+        with tempfile.TemporaryDirectory() as output_dir:
+            emit_manifest({'theme_topology': {}}, [], [candidate], output_dir)
+            with open(os.path.join(output_dir, 'manifest.yaml'), encoding='utf-8') as stream:
+                manifest = stream.read()
+
+        self.assertIn('source_media: glow.png', manifest)
+        self.assertIn('decision: TODO-kind-1', manifest)
+
+    def test_deterministic_fullscreen_images_skip_model_judgment(self):
+        self.assertFalse(needs_asset_judgment({
+            'fullscreen': True,
+            'probe': {'alpha_mean': 255, 'near_blank': False},
+        }))
+        self.assertFalse(needs_asset_judgment({
+            'fullscreen': True,
+            'probe': {'alpha_mean': 5, 'near_blank': True},
+        }))
+
+    def test_shape_fill_images_are_exposed_as_slide_marks(self):
+        data = {
+            'images': [{
+                'media': 'ppt/media/fill.png',
+                'fullscreen': False,
+                'boxes': [{
+                    'box': {'x': 120, 'y': 240, 'w': 360, 'h': 420},
+                    'parts': ['ppt/slides/slide2.xml'],
+                }],
+            }],
+        }
+
+        marks = slide_image_marks(data)
+
+        self.assertEqual(marks['ppt/slides/slide2.xml'], [{
+            'media': 'ppt/media/fill.png',
+            'box': {'x': 120, 'y': 240, 'w': 360, 'h': 420},
+        }])
+
+    def test_form3_layouts_include_instance_image_fills(self):
+        layouts = []
+        shapes = []
+        for index in range(1, 4):
+            part = 'ppt/slideLayouts/slideLayout%d.xml' % index
+            layouts.append({
+                'part': part,
+                'name': 'Layout %d' % index,
+                'used_by_slides': 1,
+            })
+            shapes.append({
+                'part': part,
+                'layer': 'layout',
+                'kind': 'sp',
+                'box': {'x': 10, 'y': 10, 'w': 500, 'h': 100},
+                'ph': {'type': 'title', 'idx': str(index)},
+                'text': {'paragraphs': [{'runs': [{
+                    'text': 'Title %d' % index,
+                    'sz_px': 40,
+                }]}]},
+            })
+        data = {
+            'canvas': {'px': [1920, 1080]},
+            'form_hint': {'form': 3},
+            'layouts': layouts,
+            'images': [{
+                'media': 'ppt/media/fill.png',
+                'fullscreen': False,
+                'boxes': [{
+                    'box': {'x': 120, 'y': 240, 'w': 360, 'h': 420},
+                    'parts': ['ppt/slides/slide1.xml'],
+                }],
+            }],
+            'media': [],
+            'theme_topology': {
+                'themes': ['single'],
+                'per_master': [],
+                'default': 'single',
+            },
+            'reference_graph': {
+                'master_of_layout': {},
+                'layout_of_slide': {
+                    'ppt/slides/slide1.xml': 'ppt/slideLayouts/slideLayout1.xml',
+                },
+            },
+            'background_composites': {},
+        }
+
+        with tempfile.TemporaryDirectory() as output_dir:
+            os.makedirs(os.path.join(output_dir, 'ref'))
+            with open(os.path.join(output_dir, 'ref', 'shapes.json'), 'w',
+                      encoding='utf-8') as stream:
+                import json
+                json.dump({'shapes': shapes}, stream)
+            archetypes, _, _ = draft_layouts(data, output_dir)
+
+        self.assertTrue(any(
+            slot.get('media') == 'ppt/media/fill.png'
+            for archetype in archetypes
+            for slot in archetype['slots']
+        ))
+
+    def test_shape_opacity_marks_opaque_fullscreen_media_as_overlay(self):
+        data = {
+            'media': [{
+                'media': 'ppt/media/overlay.png',
+                'out': 'media-out/overlay.png',
+            }],
+            'images': [{
+                'media': 'ppt/media/overlay.png',
+                'fullscreen': True,
+            }],
+        }
+        shapes = [{
+            'kind': 'pic',
+            'media': 'ppt/media/overlay.png',
+            'w_pct': 100,
+            'h_pct': 100,
+            'opacity': 0.25,
+        }]
+
+        with tempfile.TemporaryDirectory() as output_dir:
+            media_dir = os.path.join(output_dir, 'media-out')
+            os.makedirs(media_dir)
+            try:
+                from PIL import Image
+            except ImportError:
+                self.skipTest('Pillow unavailable')
+            Image.new('RGB', (16, 9), (20, 40, 60)).save(
+                os.path.join(media_dir, 'overlay.png'))
+
+            overlays = fullscreen_overlay_media(data, output_dir, shapes)
+
+        self.assertEqual(overlays, {'ppt/media/overlay.png'})
+
+    def test_page_with_multiple_small_images_is_kept_for_logo_wall_judgment(self):
+        page = {
+            'marks': [
+                {'media': 'ppt/media/logo-%d.png' % index,
+                 'box': {'x': index * 180, 'y': 300, 'w': 120, 'h': 100}}
+                for index in range(3)
+            ],
+        }
+
+        self.assertTrue(has_small_image_cluster([page], (1920, 1080)))
+        self.assertFalse(has_small_image_cluster([{
+            'marks': page['marks'][:2],
+        }], (1920, 1080)))
+
+    def test_single_image_orphan_reuses_nearest_layout_without_new_archetype(self):
+        archetypes = [{
+            'name': 'layout-1',
+            'slots': [],
+            'rep': 2,
+            '_source_layouts': ['ppt/slideLayouts/slideLayout1.xml'],
+            '_source_backgrounds': ['ppt/media/bg.png'],
+            '_text_n': 4,
+        }, {
+            'name': 'layout-2',
+            'slots': [],
+            'rep': 8,
+            '_source_layouts': ['ppt/slideLayouts/slideLayout2.xml'],
+            '_source_backgrounds': ['ppt/media/other-bg.png'],
+            '_text_n': 12,
+        }]
+        pages = [{
+            'part': 'ppt/slides/slide11.xml',
+            'no': 11,
+            'layout': 'ppt/slideLayouts/slideLayout1.xml',
+            'rendered_bg': 'ppt/media/bg.png',
+            'bg_media': None,
+            'bg_color': None,
+            'texts': [{}, {}, {}, {}, {}],
+            'marks': [{
+                'media': 'ppt/media/ornament.png',
+                'box': {'x': 40, 'y': 120, 'w': 80, 'h': 240},
+            }],
+        }]
+
+        attach_leftover_image_marks(archetypes, pages, kept_parts=set())
+
+        self.assertEqual(len(archetypes), 2)
+        self.assertEqual(archetypes[0]['slots'], [{
+            'role': 'logo',
+            'type': 'pic',
+            'sz': 0,
+            'txt': '',
+            'media': 'ppt/media/ornament.png',
+            'box': [40, 120, 80, 240],
+        }])
+        self.assertEqual(archetypes[1]['slots'], [])
+
+    def test_contact_sheets_cover_all_candidates_without_truncation(self):
+        try:
+            from PIL import Image
+        except ImportError:
+            self.skipTest('Pillow unavailable')
+
+        with tempfile.TemporaryDirectory() as output_dir:
+            media_dir = os.path.join(output_dir, 'media-out')
+            lout_dir = os.path.join(output_dir, 'l-out')
+            os.makedirs(media_dir)
+            os.makedirs(lout_dir)
+            candidates = []
+            for index in range(13):
+                filename = 'image-%02d.png' % index
+                Image.new('RGBA', (8, 8), (index, 20, 30, 255)).save(
+                    os.path.join(media_dir, filename))
+                candidates.append({
+                    'file': filename,
+                    'out': 'media-out/' + filename,
+                    'n': 1,
+                    'probe': {'w': 8, 'h': 8},
+                })
+
+            sheets = contact_sheets(output_dir, candidates, lout_dir)
+            legacy_exists = os.path.exists(os.path.join(lout_dir, 'contact-sheet.png'))
+
+        self.assertEqual(len(sheets), 2)
+        self.assertEqual(
+            [os.path.basename(path) for path in sheets],
+            ['contact-sheet-1.png', 'contact-sheet-2.png'],
+        )
+        self.assertTrue(legacy_exists)
+
+    def test_content_candidates_at_same_geometry_collapse_to_one_slot(self):
+        lines = resolve_asset_candidate_lines([
+            '      - {role: asset-candidate, box: [10, 20, 300, 200], type: pic, '
+            'source_media: chart-a.png}',
+            '      - {role: asset-candidate, box: [10, 20, 300, 200], type: pic, '
+            'source_media: chart-b.png}',
+        ], {
+            'chart-a.png': 'content',
+            'chart-b.png': 'content',
+        }, {})
+
+        self.assertEqual(lines, [
+            '      - {role: pic, box: [10, 20, 300, 200], type: pic}',
+        ])
+
+
+if __name__ == '__main__':
+    unittest.main()

package/steering/design-html/skills/pptx-style-extract/scripts/test_rounded_contract.py

@@ -0,0 +1,112 @@
+#!/usr/bin/env python3
+"""Regression tests for preserving per-container radii."""
+import os
+import tempfile
+import unittest
+
+from draft import emit_body, emit_frontmatter
+from query import _recipe_css
+
+
+def render_frontmatter(radii):
+    data = {
+        'radii_census': radii,
+        'spacing_candidates': {},
+    }
+    tokens = [('surface', {'hex': '#FFFFFF'})]
+
+    with tempfile.TemporaryDirectory() as output_dir:
+        emit_frontmatter(
+            data,
+            tokens,
+            [],
+            {},
+            [],
+            [],
+            output_dir,
+        )
+        with open(os.path.join(output_dir, 'frontmatter.yaml'), encoding='utf-8') as stream:
+            return stream.read()
+
+
+def render_body():
+    data = {
+        'canvas': {'px': [1920, 1080]},
+        'form_hint': {'form': 2},
+        'counts': {'slides': 1},
+    }
+
+    with tempfile.TemporaryDirectory() as output_dir:
+        emit_body(
+            data,
+            [],
+            [],
+            {},
+            [],
+            [],
+            [],
+            {},
+            output_dir,
+        )
+        with open(os.path.join(output_dir, 'body.md'), encoding='utf-8') as stream:
+            return stream.read()
+
+
+class RoundedContractTest(unittest.TestCase):
+    def test_multiple_radius_tiers_are_not_collapsed_into_one_card_token(self):
+        frontmatter = render_frontmatter(
+            [
+                {'px': 6.9, 'n': 2},
+                {'px': 11.9, 'n': 2},
+                {'px': 14.4, 'n': 3},
+            ]
+        )
+
+        self.assertNotIn('rounded:', frontmatter)
+
+    def test_single_radius_tier_can_remain_a_global_token(self):
+        frontmatter = render_frontmatter([{'px': 12, 'n': 9}])
+
+        self.assertIn('rounded:\n  card: 12px', frontmatter)
+
+    def test_rare_rounded_exceptions_do_not_override_a_zero_radius_majority(self):
+        frontmatter = render_frontmatter(
+            [
+                {'px': 0, 'n': 241},
+                {'px': 3.4, 'n': 4},
+                {'px': 6.9, 'n': 3},
+                {'px': 50.5, 'n': 1},
+            ]
+        )
+
+        self.assertNotIn('rounded:', frontmatter)
+
+    def test_generated_usage_defaults_unspecified_container_radius_to_zero(self):
+        body = render_body()
+
+        self.assertIn('没有 `border-radius` 就按 `0`', body)
+        self.assertIn('不得自行补圆角', body)
+
+    def test_recipe_does_not_promote_one_rounded_exception_to_the_whole_group(self):
+        css = _recipe_css(
+            {'type': 'solid', 'color': {'hex': '#FFFFFF'}},
+            None,
+            [0] * 70 + [50.5],
+            None,
+        )
+
+        self.assertFalse(any('border-radius' in declaration for declaration in css))
+
+    def test_recipe_keeps_a_radius_shared_by_the_whole_group(self):
+        css = _recipe_css(
+            {'type': 'solid', 'color': {'hex': '#FFFFFF'}},
+            None,
+            [6.9] * 17,
+            None,
+        )
+
+        self.assertIn('border-radius: 6.9px', css)
+
+
+if __name__ == '__main__':
+    unittest.main()