@lark-apaas/coding-steering 0.1.32-dev.4f80f68 → 0.1.32-dev.942e73f

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

@@ -3,18 +3,33 @@
 import io
 import os
 import sys
+import tempfile
 import unittest
+from unittest import mock
+from xml.etree import ElementTree as ET
 
 from PIL import Image
 
 sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
 
-from extract import _draw_picture  # noqa: E402
+import extract  # noqa: E402
+from extract import (  # noqa: E402
+    _draw_picture,
+    _is_full_canvas_fill_overlay,
+    compose_backgrounds,
+    export_media,
+    export_visible_picture_instances,
+)
+from census import image_census  # noqa: E402
+from ooxml import Units  # noqa: E402
+from parts import walk_tree  # noqa: E402
+from render_pages import background_css  # noqa: E402
 
 
 class _Archive:
     def __init__(self, media, raw):
         self.names = {media}
+        self.media = [media]
         self.zip = self
         self.raw = raw
 
@@ -23,6 +38,35 @@ class _Archive:
             raise KeyError(media)
         return self.raw
 
+    def size_of(self, media):
+        if media not in self.names:
+            raise KeyError(media)
+        return len(self.raw)
+
+
+class _CompositeArchive(_Archive):
+    def __init__(self, media, raw, slide):
+        super().__init__(media, raw)
+        self.layouts = []
+        self.slides = [slide]
+
+    @staticmethod
+    def xml(_part):
+        return {}
+
+
+class _ShapeContext:
+    def __init__(self, media):
+        self.part = 'ppt/slides/slide1.xml'
+        self.layer = 'slide'
+        self.units = Units(1920, 1080)
+        self.clrmap = {}
+        self.clrscheme = {}
+        self.media = media
+
+    def media_of(self, _relationship_id):
+        return self.media
+
 
 def _png(pixels):
     image = Image.new('RGBA', (len(pixels), 1))
@@ -52,6 +96,269 @@ class BackgroundCompositeTest(unittest.TestCase):
         self.assertEqual(left[3], 255)
         self.assertEqual(right[3], 255)
 
+    def test_exports_a_cropped_rotated_visible_instance_from_a_near_blank_source(self):
+        media = 'ppt/media/source.png'
+        source = Image.new('RGBA', (1000, 1000))
+        for x in range(460, 540):
+            for y in range(460, 540):
+                source.putpixel((x, y), (15, 80, 160, 255))
+        raw = io.BytesIO()
+        source.save(raw, 'PNG')
+        package = _Archive(media, raw.getvalue())
+        shape = {
+            'kind': 'pic',
+            'media': media,
+            'part': 'ppt/slides/slide2.xml',
+            'box_unrotated': {'x': 100, 'y': 200, 'w': 20, 'h': 100},
+            'box': {'x': 50, 'y': 240, 'w': 120, 'h': 20},
+            'crop': {'l': 40, 't': 40, 'r': 40, 'b': 40},
+            'rot': 90,
+        }
+
+        with tempfile.TemporaryDirectory() as outdir:
+            rows = export_visible_picture_instances(package, [shape], outdir, True)
+            self.assertEqual(len(rows), 1)
+            self.assertTrue(rows[0]['generated'])
+            self.assertEqual(rows[0]['rendered_from'], media)
+            self.assertTrue(shape['media'].startswith('generated/instance/'))
+
+            rendered = Image.open(os.path.join(outdir, rows[0]['out'])).convert('RGBA')
+            self.assertGreater(rendered.width, rendered.height)
+            self.assertGreater(sum(pixel[3] for pixel in rendered.getdata()) / rendered.width
+                               / rendered.height, 13)
+
+    def test_instance_webp_writer_removes_partial_output_after_a_save_error(self):
+        canvas = Image.new('RGBA', (1, 1), (15, 80, 160, 255))
+
+        with tempfile.TemporaryDirectory() as outdir:
+            path = os.path.join(outdir, 'instance.webp')
+            with mock.patch.object(Image.Image, 'save', side_effect=OSError('webp unavailable')):
+                reason = extract._save_picture_instance_webp(canvas, path)
+
+            self.assertEqual('pillow-error: OSError: webp unavailable', reason)
+            self.assertFalse(os.path.exists(path))
+            self.assertFalse(os.path.exists(path + '.tmp'))
+
+    def test_instance_webp_failure_keeps_the_source_media_and_records_the_reason(self):
+        media = 'ppt/media/source.png'
+        package = _Archive(media, _png([(15, 80, 160, 255)]))
+        shape = {
+            'kind': 'pic',
+            'media': media,
+            'part': 'ppt/slides/slide2.xml',
+            'layer': 'slide',
+            'box_unrotated': {'x': 0, 'y': 0, 'w': 100, 'h': 100},
+            'box': {'x': 0, 'y': 0, 'w': 100, 'h': 100},
+            'rot': 90,
+        }
+
+        with tempfile.TemporaryDirectory() as outdir:
+            blocked = {}
+            with mock.patch.object(
+                    extract, '_save_picture_instance_webp',
+                    return_value='pillow-error: OSError: webp unavailable'):
+                rows = export_visible_picture_instances(
+                    package, [shape], outdir, True, blocked)
+            images, _ = image_census([shape], [], Units(1920, 1080))
+            media_rows = export_media(package, images, outdir, True)
+
+        self.assertEqual([], rows)
+        self.assertEqual(media, shape['media'])
+        self.assertTrue(images[0]['visible_instance_blocked'])
+        self.assertTrue(media_rows[0]['candidate'])
+        self.assertIn('visible_instance_fallback', media_rows[0]['reasons'])
+        self.assertEqual({
+            media: {
+                'reason': 'pillow-error: OSError: webp unavailable',
+                'attempted_specs': 1,
+                'part_refs': ['ppt/slides/slide2.xml'],
+            },
+        }, blocked)
+
+    def test_alpha_modulations_combine_for_a_visible_instance(self):
+        media = 'ppt/media/source.png'
+        package = _Archive(media, _png([(20, 40, 60, 255)]))
+        picture_tree = ET.fromstring('''
+            <p:spTree xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main"
+                xmlns:p="http://schemas.openxmlformats.org/presentationml/2006/main"
+                xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships">
+              <p:pic>
+                <p:nvPicPr><p:cNvPr id="1" name="half-alpha"/><p:cNvPicPr/><p:nvPr/></p:nvPicPr>
+                <p:blipFill>
+                  <a:blip r:embed="rId1">
+                    <a:alphaMod amt="50000"/>
+                    <a:alphaModFix amt="50000"/>
+                  </a:blip>
+                  <a:stretch><a:fillRect/></a:stretch>
+                </p:blipFill>
+                <p:spPr>
+                  <a:xfrm><a:off x="0" y="0"/><a:ext cx="100" cy="100"/></a:xfrm>
+                  <a:prstGeom prst="rect"><a:avLst/></a:prstGeom>
+                </p:spPr>
+              </p:pic>
+            </p:spTree>
+        ''')
+        shapes = []
+        walk_tree(picture_tree, _ShapeContext(media), shapes)
+
+        self.assertEqual(shapes[0]['opacity'], 0.25)
+        with tempfile.TemporaryDirectory() as outdir:
+            rows = export_visible_picture_instances(package, shapes, outdir, True)
+            self.assertEqual(len(rows), 1)
+            rendered = Image.open(os.path.join(outdir, rows[0]['out'])).convert('RGBA')
+            self.assertAlmostEqual(rendered.getpixel((50, 50))[3], 64, delta=2)
+
+    def test_composites_full_canvas_gradient_and_solid_fill_overlays(self):
+        media = 'ppt/media/source.png'
+        slide = 'ppt/slides/slide1.xml'
+        package = _CompositeArchive(media, _png([(0, 0, 255, 255)]), slide)
+        picture = {
+            'part': slide,
+            'kind': 'pic',
+            'media': media,
+            'box_unrotated': {'x': 0, 'y': 0, 'w': 2, 'h': 1},
+            'w_pct': 100,
+            'h_pct': 100,
+        }
+        shape_base = {
+            'geom': {'prst': 'rect'},
+            'line': {'none': True},
+        }
+        gradient_overlay = {
+            **shape_base,
+            'part': slide,
+            'kind': 'sp',
+            'box_unrotated': {'x': 0, 'y': 0, 'w': 2, 'h': 1},
+            'w_pct': 100,
+            'h_pct': 100,
+            'fill': {
+                'type': 'gradient',
+                'stops': [
+                    {'pos': 0, 'color': {'resolved': 'rgba(255,0,0,0.5)'}},
+                    {'pos': 100, 'color': {'resolved': 'rgba(255,0,0,0.5)'}},
+                ],
+                'angle_deg': 0,
+            },
+        }
+        solid_overlay = {
+            **shape_base,
+            'part': slide,
+            'kind': 'sp',
+            'box_unrotated': {'x': 0, 'y': 0, 'w': 2, 'h': 1},
+            'w_pct': 100,
+            'h_pct': 100,
+            'fill': {
+                'type': 'solid',
+                'color': {'resolved': 'rgba(0,255,0,0.5)'},
+            },
+        }
+        text_overlay = dict(solid_overlay, text={
+            'paragraphs': [{'runs': [{'text': 'Do not flatten me'}]}],
+        })
+
+        self.assertTrue(_is_full_canvas_fill_overlay(gradient_overlay))
+        self.assertFalse(_is_full_canvas_fill_overlay(text_overlay))
+        self.assertFalse(_is_full_canvas_fill_overlay({
+            **gradient_overlay,
+            'fill': {**gradient_overlay['fill'], 'path': 'circle'},
+        }))
+        with tempfile.TemporaryDirectory() as outdir:
+            part_map, rows, _ = compose_backgrounds(
+                package,
+                {'layout_of_slide': {}, 'master_of_layout': {}},
+                [picture, gradient_overlay, solid_overlay, text_overlay],
+                {},
+                Units(2, 1),
+                outdir,
+                True,
+            )
+
+            self.assertEqual(set(part_map), {slide})
+            self.assertEqual(len(rows), 1)
+            self.assertEqual(
+                [layer['kind'] for layer in rows[0]['composited_from']],
+                ['picture', 'fill_overlay', 'fill_overlay'],
+            )
+            rendered = Image.open(os.path.join(outdir, rows[0]['out'])).convert('RGB')
+            red, green, blue = rendered.getpixel((0, 0))
+            self.assertGreater(red, 50)
+            self.assertGreater(green, 100)
+            self.assertGreater(blue, 50)
+
+    def test_preserves_fill_and_picture_draw_order(self):
+        media = 'ppt/media/source.png'
+        slide = 'ppt/slides/slide1.xml'
+        package = _CompositeArchive(media, _png([(0, 0, 255, 255)]), slide)
+        overlay = {
+            'part': slide,
+            'kind': 'sp',
+            'geom': {'prst': 'rect'},
+            'line': {'none': True},
+            'box_unrotated': {'x': 0, 'y': 0, 'w': 2, 'h': 1},
+            'w_pct': 100,
+            'h_pct': 100,
+            'fill': {'type': 'solid', 'color': {'resolved': 'rgba(255,0,0,0.5)'}},
+        }
+        picture = {
+            'part': slide,
+            'kind': 'pic',
+            'media': media,
+            'box_unrotated': {'x': 0, 'y': 0, 'w': 2, 'h': 1},
+            'w_pct': 100,
+            'h_pct': 100,
+        }
+
+        with tempfile.TemporaryDirectory() as outdir:
+            _, rows, _ = compose_backgrounds(
+                package,
+                {'layout_of_slide': {}, 'master_of_layout': {}},
+                [overlay, picture],
+                {},
+                Units(2, 1),
+                outdir,
+                True,
+            )
+
+            rendered = Image.open(os.path.join(outdir, rows[0]['out'])).convert('RGB')
+            self.assertEqual(rendered.getpixel((0, 0)), (0, 0, 255))
+
+    def test_path_gradient_background_is_not_linearized_for_compositing(self):
+        media = 'ppt/media/source.png'
+        slide = 'ppt/slides/slide1.xml'
+        package = _CompositeArchive(media, _png([(0, 0, 255, 255)]), slide)
+        picture = {
+            'part': slide,
+            'kind': 'pic',
+            'media': media,
+            'box_unrotated': {'x': 0, 'y': 0, 'w': 2, 'h': 1},
+            'w_pct': 100,
+            'h_pct': 100,
+            'rot': 90,
+        }
+        background = {
+            'type': 'gradient',
+            'path': 'circle',
+            'stops': [
+                {'pos': 0, 'color': {'resolved': '#FF0000'}},
+                {'pos': 100, 'color': {'resolved': '#00FF00'}},
+            ],
+        }
+
+        self.assertIsNone(background_css(background))
+        with tempfile.TemporaryDirectory() as outdir:
+            _, rows, _ = compose_backgrounds(
+                package,
+                {'layout_of_slide': {}, 'master_of_layout': {}},
+                [picture],
+                {slide: background},
+                Units(2, 1),
+                outdir,
+                True,
+            )
+
+            rendered = Image.open(os.path.join(outdir, rows[0]['out'])).convert('RGB')
+            self.assertEqual(rendered.getpixel((0, 0)), (0, 0, 255))
+
 
 if __name__ == '__main__':
     unittest.main()

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

@@ -56,6 +56,12 @@ class DesignConsumerContractTest(unittest.TestCase):
         self.assertIn('沿用该页型已有的标题层级与局部 `css`', body)
         self.assertIn('背景中已经可见的固定标题不再创建文本', body)
         self.assertIn('没有 `subtitle` 槽就不新增副标题', body)
+        self.assertIn('区带自带 `margin: [左, 右]` 时用它的', body)
+        self.assertIn('必须完整阅读本 `design.md` 和 `layouts.md`', body)
+        self.assertIn('确认全部页型后再开始搭页', body)
+        self.assertIn('不能只看摘要、前几个页型', body)
+        self.assertIn('data-pptx-layout="<页型名>"', body)
+        self.assertIn('交付前据此核验 logo 只出现在该页型的资产槽中', body)
 
 
 if __name__ == '__main__':

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

@@ -9,7 +9,8 @@ sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
 
 from draft import draft_flow, draft_layouts, emit_layouts
 from check_v2 import Pack, rule_v2_14, rule_v2_16
-from package import Fail, build_layouts_md, split_top_blocks
+from package import (Fail, apply_asset_decisions, build_layouts_md,
+                     split_top_blocks)
 
 
 def text_slot(role, box, text):
@@ -101,7 +102,7 @@ layouts:
         self.assertNotIn('    flow:', slots_md)
         self.assertNotIn('layout_modes:', slots_md)
 
-    def test_layout_mode_is_required_when_both_forms_exist(self):
+    def test_layout_mode_defaults_to_slots_when_both_forms_exist(self):
         draft = """names:
   layout-1: 内容页
 roles:
@@ -123,8 +124,56 @@ layouts:
     confidence: high
 """
 
-        with self.assertRaisesRegex(Fail, 'layout-1 缺 layout_modes 判断'):
-            build_layouts_md(split_top_blocks(draft), (1920, 1080))
+        layouts_md = build_layouts_md(split_top_blocks(draft), (1920, 1080))
+
+        self.assertIn('    slots:', layouts_md)
+        self.assertNotIn('    flow:', layouts_md)
+
+    def test_flow_instance_override_uses_source_box_without_leaking_it(self):
+        manifest = {
+            'assets': [],
+            'asset_vision_groups': [{
+                'id': 'vision-1',
+                'source_media': '[shared.png]',
+                'visual_kind': 'content-image',
+            }],
+            'asset_decisions': [{
+                'source_media': 'shared.png',
+                'box': '[100, 200, 80, 80]',
+                'visual_kind': 'decorative',
+            }],
+        }
+        decisions, asset_ids = apply_asset_decisions(manifest)
+        draft = """names:
+  layout-1: 内容页
+roles:
+  layout-1: content
+layout_modes:
+  layout-1: flow
+layouts:
+  layout-1:
+    flow:
+      top: 100
+      margin: [80, 80]
+      gap: 40
+      regions:
+        - kind: stack
+          gap: 20
+          items:
+            - {role: asset-candidate, type: pic, source_media: shared.png, source_box: [100, 200, 80, 80]}
+    slots:
+      - {role: asset-candidate, box: [100, 200, 80, 80], type: pic, source_media: shared.png}
+    confidence: high
+"""
+
+        layouts_md = build_layouts_md(
+            split_top_blocks(draft), (1920, 1080),
+            asset_decisions=decisions, asset_ids=asset_ids,
+        )
+
+        self.assertIn('- {role: texture, type: pic, asset: texture-1}', layouts_md)
+        self.assertNotIn('source_media', layouts_md)
+        self.assertNotIn('source_box', layouts_md)
 
     def test_layout_mode_rejects_unknown_value(self):
         draft = """names:
@@ -262,14 +311,22 @@ layouts:
             with open(os.path.join(output_dir, 'layouts.yaml'), encoding='utf-8') as stream:
                 layouts_yaml = stream.read()
 
-        self.assertIn('layout_modes:', layouts_yaml)
-        self.assertIn('  layout-1: TODO布局模式', layouts_yaml)
+        self.assertNotIn('\nlayout_modes:\n', layouts_yaml)
+        self.assertIn('默认保留 slots', layouts_yaml)
         self.assertIn('        - kind: grid\n          cols: 3', layouts_yaml)
         self.assertEqual(layouts_yaml.count('            - role: group'), 3)
         self.assertEqual(layouts_yaml.count('              items:'), 3)
         self.assertEqual(layouts_yaml.count('role: container'), 3)
 
-        decided = layouts_yaml.replace('TODO布局模式', 'flow')
+        default_layouts_md = build_layouts_md(split_top_blocks(layouts_yaml), (1920, 1080))
+
+        self.assertNotIn('    flow:', default_layouts_md)
+        self.assertIn('    slots:', default_layouts_md)
+
+        decided = layouts_yaml.replace(
+            'layouts:',
+            'layout_modes:\n  layout-1: flow\nlayouts:',
+        )
         layouts_md = build_layouts_md(split_top_blocks(decided), (1920, 1080))
 
         self.assertNotIn('layout_modes:', layouts_md)
@@ -324,6 +381,99 @@ layouts:
             ['group', 'group', 'group'],
         )
 
+    def test_centered_card_grid_carries_its_own_symmetric_margin(self):
+        # 短标题贴左（x=120..900），三张卡片居中（左右各 360）。整页 margin 取「最左槽 +
+        # 最右槽」的外包络 = [120, 360]，直接套给居中卡片组会把它拉偏成左对齐（左缝小、
+        # 右缝大）。卡片区带应带自己的对称 margin，还原居中。
+        archetype = {
+            'name': 'layout-1',
+            'zh': '标题加三列卡片',
+            'role': 'content',
+            'bg': None,
+            'slots': [
+                text_slot('title', [120, 73, 780, 68], '核心能力'),
+            ],
+            'decor': [],
+            'pages': [2],
+            'rep': 2,
+            'pic_n': 0,
+            'confidence': 'high',
+        }
+        for left in (360, 760, 1160):
+            archetype['decor'].append({
+                'box': [left, 430, 400, 300],
+                'geom': 'rect',
+                'css': 'background: rgba(255,255,255,0.7)',
+            })
+            for top in (490, 570):
+                archetype['slots'].append(
+                    text_slot('body', [left + 40, top, 320, 41], '卡片内容'),
+                )
+
+        flow = draft_flow(archetype, {}, (1920, 1080))
+
+        self.assertIsNotNone(flow)
+        self.assertEqual([region['kind'] for region in flow['regions']], ['stack', 'grid'])
+        self.assertEqual(flow['margin'], [120, 360])
+        grid = flow['regions'][1]
+        self.assertEqual(grid.get('margin'), [360, 360])
+
+        archetype['flow'] = flow
+        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()
+        decided = layouts_yaml.replace(
+            'layouts:',
+            'layout_modes:\n  layout-1: flow\nlayouts:',
+        )
+        layouts_md = build_layouts_md(split_top_blocks(decided), (1920, 1080))
+        self.assertRegex(layouts_md, r'- kind: grid\n\s+cols: 3\n\s+gap: \[\d+, \d+\]\n\s+margin: \[360, 360\]')
+
+    def test_symmetric_card_grid_omits_region_margin(self):
+        # 卡片组横向范围已和整页一致（都对称），不该冒出多余的区带 margin——保证对已有
+        # 对称模板零回归、layouts.md 不膨胀。
+        archetype = {
+            'name': 'layout-1',
+            'zh': '标题加三列卡片',
+            'role': 'content',
+            'bg': None,
+            'slots': [
+                text_slot('title', [120, 73, 1680, 68], '核心能力'),
+            ],
+            'decor': [],
+            'pages': [2],
+            'rep': 2,
+            'pic_n': 0,
+            'confidence': 'high',
+        }
+        for left in (120, 720, 1320):
+            archetype['decor'].append({
+                'box': [left, 430, 480, 300],
+                'geom': 'rect',
+                'css': 'background: rgba(255,255,255,0.7)',
+            })
+            for top in (490, 570):
+                archetype['slots'].append(
+                    text_slot('body', [left + 40, top, 400, 41], '卡片内容'),
+                )
+
+        flow = draft_flow(archetype, {}, (1920, 1080))
+
+        self.assertIsNotNone(flow)
+        self.assertEqual(flow['margin'], [120, 120])
+        grid = flow['regions'][1]
+        self.assertEqual(grid['kind'], 'grid')
+        self.assertNotIn('margin', grid)
+
+        archetype['flow'] = flow
+        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()
+        grid_block = layouts_yaml.split('- kind: grid', 1)[1].split('items:', 1)[0]
+        self.assertNotIn('margin:', grid_block)
+
     def test_fixed_template_anchors_stay_in_a_positioned_free_region(self):
         archetype = {
             'name': 'layout-1',