mkit-cli 0.3.1__py3-none-any.whl

mkit/commands/store.py

@@ -0,0 +1,263 @@
+"""Store listing, what's new, data safety and testers."""
+import json
+from datetime import datetime
+
+from .. import datasafety, kinds, safety
+from ..cloud import auth, play, store
+from ..errors import DRIFT, UsageError
+from ..git import Repo
+from ..registry import Arg, command, group
+
+group('listing', 'store listing text, images and contact details')
+group('whatsnew', "release notes (what's new) files")
+group('datasafety', 'the data safety declaration')
+group('testers', 'Google Groups on testing tracks')
+
+SCOPE_ARGS = (Arg('text_only', 'only the text', kind='flag'),
+              Arg('images_only', 'only the images', kind='flag'))
+LOCALES_ARG = Arg('locales', 'only these Play locales, comma separated, e.g. de-DE,es-ES (a staged rollout)')
+
+
+def _only(args):
+    if not getattr(args, 'locales', None):
+        return None
+    return {loc.strip() for loc in args.locales.split(',') if loc.strip()}
+
+
+def _scope(args):
+    if args.text_only and args.images_only:
+        raise UsageError('pass only one of --text-only / --images-only')
+    return not args.images_only, not args.text_only
+
+
+def _show_plan(out, result):
+    if out.json:
+        return
+    for c in result['text']:
+        out.line(f'  text   {c["locale"]:8} {"new locale" if c["new"] else ", ".join(c["fields"])}')
+    for c in result['images']:
+        out.line(f'  images {c["locale"]:8} {c["type"]}: {c["remote"]} on Play -> {c["local"]} local')
+    for k, v in result['details'].items():
+        out.line(f'  detail {k}: {v["from"] or "(empty)"} -> {v["to"]}')
+    if result['remote_only']:
+        out.line(f'  on Play but not in the files (left alone): {", ".join(result["remote_only"])}', 'dim')
+    if result.get('no_listing'):
+        out.line(f'  images not planned, no listing on Play yet (apply the text first): '
+                 f'{", ".join(result["no_listing"])}', 'yellow')
+    if not store.plan_size(result):
+        out.line('  no changes: Play matches the files', 'green')
+
+
+def _compare(ctx, edit, text, images, only=None):
+    out = ctx.out
+    out.step('Compare with Play' + (f' ({len(only)} locale(s) only)' if only else ''))
+    result = store.plan(edit, ctx.project, ctx.project.kind, with_images=images, with_text=text,
+                        progress=lambda d, t, item: out.progress(d, t, item), only=only)
+    out.done(f'{store.plan_size(result)} change(s), {store.upload_count(result)} image(s) to send')
+    return result
+
+
+@command('listing plan', 'Show how the listing files differ from Play (changes nothing)',
+         risk='plan', needs=('play', 'store'), args=SCOPE_ARGS + (LOCALES_ARG,),
+         examples=('mkit listing plan', 'mkit listing plan --text-only',
+                   'mkit listing plan --locales de-DE,es-ES'))
+def listing_plan(ctx, args):
+    text, images = _scope(args)
+    ctx.out.start(f'{ctx.project.name} listing plan', 1)
+    with play.Edit(ctx) as edit:
+        result = _compare(ctx, edit, text, images, _only(args))
+    _show_plan(ctx.out, result)
+    if store.plan_size(result):
+        ctx.exit_code = DRIFT
+    return store.public(result)
+
+
+@command('listing apply', 'Push listing changes (only what differs) to Play', risk='publish',
+         needs=('play', 'store'),
+         args=SCOPE_ARGS + (LOCALES_ARG,
+                            Arg('resubmit', 'cancel a review already running and resubmit everything',
+                                kind='flag')),
+         examples=('mkit listing apply', 'mkit listing apply --text-only --dry-run',
+                   'mkit listing apply --locales de-DE,es-ES,es-419,pt-BR'))
+def listing_apply(ctx, args):
+    text, images = _scope(args)
+    out = ctx.out
+    out.start(f'{ctx.project.name} listing', 4)
+    with play.Edit(ctx) as edit:
+        result = _compare(ctx, edit, text, images, _only(args))
+        _show_plan(out, result)
+        if not store.plan_size(result):
+            return dict(store.public(result), changed=False)
+        safety.confirm(ctx, f'Publish {store.plan_size(result)} listing change(s) for {ctx.project.name}')
+        workers = store._workers(ctx.project)
+        out.step(f'Send text ({len(result["text"])} language(s))')
+        progress = lambda d, t, item: out.progress(d, t, item)  # noqa: E731
+        store.apply(edit, {**result, 'images': [], 'details': {}}, workers, on_text=progress)
+        out.done()
+        out.step(f'Send images ({store.upload_count(result)} file(s), {workers} at a time)')
+        store.apply(edit, {**result, 'text': []}, workers, on_image=progress)
+        out.done()
+        out.step('Validate and commit')
+        edit.finish(ctx.dry_run, in_review='resubmit' if args.resubmit else 'error')
+        out.done()
+    if not ctx.out.json:
+        if ctx.dry_run:
+            ctx.out.line('validated on Play; nothing committed (dry run)', 'green')
+        elif edit.manual_review:
+            ctx.out.line('committed; send it for review in Play Console (see the warning)', 'green')
+        else:
+            ctx.out.line('committed; Play reviews listing changes before they show', 'green')
+    return dict(store.public(result), changed=not ctx.dry_run, dry_run=ctx.dry_run,
+                sent_for_review=not ctx.dry_run and not edit.manual_review)
+
+
+@command('listing pull', 'Save the live listing (all locales) to a JSON backup', risk='read',
+         needs=('play',), args=(Arg('out', 'file to write (default: a timestamped backup)'),))
+def listing_pull(ctx, args):
+    with play.Edit(ctx) as edit:
+        listings = edit.call(lambda e, p, i: e.listings().list(packageName=p, editId=i),
+                             'read listings').get('listings', [])
+        details = edit.call(lambda e, p, i: e.details().get(packageName=p, editId=i), 'read details')
+    data = {'package': ctx.project.package, 'details': details,
+            'listings': {l['language']: l for l in listings}}
+    if args.out:
+        path = ctx.project.root / args.out
+    else:
+        folder = ctx.project.path('store.backup_dir', 'console')
+        folder.mkdir(parents=True, exist_ok=True)
+        path = folder / f'backup-listings-{datetime.now():%Y%m%d-%H%M%S}.json'
+    path.write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding='utf-8')
+    if not ctx.out.json:
+        ctx.out.line(f'{len(listings)} locale(s) saved to {path}')
+    return {'file': str(path), 'locales': sorted(data['listings'])}
+
+
+@command('whatsnew check', "Check the what's new files: lengths and locales", risk='read', needs=('store',))
+def whatsnew_check(ctx, args):
+    notes = play.release_notes(ctx.project)
+    configured = set()
+    if ctx.project.section('store').get('locales'):
+        configured = {loc for t in store.locales(ctx.project).values() for loc in t}
+    have = {n['language'] for n in notes}
+    missing = sorted(configured - have)
+    style = {n['language']: why for n in notes if (why := play.note_problems(n['text']))}
+    repo = Repo(ctx.project.root)
+    last = repo.last_release() if notes and repo.is_repo() else ''
+    unchanged = bool(last) and not repo.changed_since(last, ctx.project.path('store.whatsnew_dir'))
+    if not ctx.out.json:
+        for n in notes:
+            ctx.out.line(f'  {n["language"]:8} {len(n["text"]):3}/{play.WHATSNEW_LIMIT}  '
+                         f'{n["text"].splitlines()[0][:60]}')
+        for lang, why in sorted(style.items()):
+            ctx.out.line(f'  {lang}: {", ".join(why)}', 'red')
+        if missing:
+            ctx.out.line(f'  no note for: {", ".join(missing)} (those languages see the default)', 'yellow')
+        if unchanged:
+            ctx.out.line(f'  unchanged since the last release ({last[:7]}): deploy will refuse it '
+                         'without --same-notes', 'yellow')
+    if style:
+        ctx.exit_code = 1
+    return {'notes': notes, 'missing': missing, 'style': style, 'unchanged_since_release': unchanged}
+
+
+@command('datasafety check', 'Check the data safety CSV (no upload)', risk='read', needs=('store',))
+def datasafety_check(ctx, args):
+    info = store.read_datasafety(ctx.project)
+    info.pop('text')
+    if not ctx.out.json:
+        ctx.out.line(f'{info["path"]}: {info["rows"]} rows, {info["answered"]} answered')
+        ctx.out.line(f'  collects data: {info["collects_data"] or "?"}')
+        ctx.out.line(f'  data types:    {", ".join(info["data_types"]) or "none"}')
+        for q in info['required_blank']:
+            ctx.out.line(f'  REQUIRED but blank: {q}', 'yellow')
+    if info['required_blank']:
+        ctx.exit_code = 1
+    return info
+
+
+@command('datasafety build', 'Write the data safety CSV from [datasafety] in mkit.toml',
+         risk='write', needs=('store',),
+         examples=('mkit datasafety build', 'mkit datasafety build --show'),
+         args=(Arg('show', 'print the answers without writing the file', kind='flag'),))
+def datasafety_build(ctx, args):
+    """The 782 questions are the same for every app; only the answers differ.
+
+    So the question set ships with the engine and an app declares what it
+    collects, rather than each repo carrying its own filled copy of Google's
+    sample CSV and drifting from the others.
+    """
+    text, info = datasafety.build(ctx.project.section('datasafety'))
+    path = ctx.project.path('store.datasafety')
+    if not path:
+        raise UsageError('no datasafety path set under [store]',
+                         hint='Add datasafety = "docs/data-safety/<app>.csv" under [store].',
+                         code='NO_DATASAFETY_PATH')
+    if not args.show:
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(text, encoding='utf-8', newline='')
+    if not ctx.out.json:
+        ctx.out.line(f'{"would write" if args.show else "wrote"} {path}: {info["rows"]} rows')
+        ctx.out.line(f'  collects:   {", ".join(info["data_types"]) or "nothing"}')
+    return {'path': str(path), 'written': not args.show, **info}
+
+
+@command('datasafety types', 'Every data type a declaration can name', risk='read')
+def datasafety_types(ctx, args):
+    """What [datasafety.collected] accepts, so nobody has to guess a spelling."""
+    types = [{'id': t['id'], 'names': t['names'], 'label': t['label']}
+             for t in datasafety.data_types().values()]
+    if not ctx.out.json:
+        for t in types:
+            ctx.out.line(f'  {t["names"][0]:26s} {t["label"]}')
+        ctx.out.line('')
+        ctx.out.line('  purposes: ' + ', '.join(sorted(datasafety.PURPOSES)))
+    return {'types': types, 'purposes': sorted(datasafety.PURPOSES)}
+
+
+@command('datasafety apply', 'Upload the data safety declaration (replaces the one on Play)',
+         risk='publish', needs=('play', 'store'))
+def datasafety_apply(ctx, args):
+    info = store.read_datasafety(ctx.project)
+    if info['required_blank']:
+        raise UsageError(f'{len(info["required_blank"])} REQUIRED question(s) are blank; Play would reject it',
+                         code='DATASAFETY_INCOMPLETE')
+    safety.confirm(ctx, f'Replace the data safety declaration of {ctx.project.package}',
+                   [f'collects data: {info["collects_data"]}',
+                    f'data types: {", ".join(info["data_types"]) or "none"}'])
+    if ctx.dry_run:
+        return {'dry_run': True, 'rows': info['rows']}
+    svc = auth.play(ctx)
+    auth.retry(lambda: svc.applications().dataSafety(packageName=ctx.project.package,
+                                                      body={'safetyLabels': info['text']}), 'data safety')
+    if not ctx.out.json:
+        ctx.out.line('data safety declaration uploaded', 'green')
+    return {'uploaded': True, 'rows': info['rows']}
+
+
+@command('testers show', 'Google Groups on each testing track', risk='read', needs=('play',))
+def testers_show(ctx, args):
+    rows = []
+    with play.Edit(ctx) as edit:
+        for t in edit.tracks():
+            if t['track'] == 'production':
+                continue
+            groups = edit.call(lambda e, p, i, tr=t['track']: e.testers().get(
+                packageName=p, editId=i, track=tr), f'testers {t["track"]}').get('googleGroups', [])
+            rows.append({'track': t['track'], 'googleGroups': groups})
+    if not ctx.out.json:
+        ctx.out.table([(r['track'], ', '.join(r['googleGroups']) or '-') for r in rows], ('track', 'groups'))
+        ctx.out.line('email tester lists are Console-only (see `mkit manual`)', 'dim')
+    return {'tracks': rows}
+
+
+@command('testers set', 'Set the Google Groups on a testing track', risk='publish', needs=('play',),
+         args=(Arg('track', 'testing track', kind='positional'),
+               Arg('groups', 'group emails', kind='positional', nargs='+')))
+def testers_set(ctx, args):
+    track = play.track_id(args.track)
+    safety.confirm(ctx, f'Set testers of {track} to {", ".join(args.groups)}')
+    with play.Edit(ctx) as edit:
+        edit.call(lambda e, p, i: e.testers().update(packageName=p, editId=i, track=track,
+                                                     body={'googleGroups': args.groups}), 'testers')
+        edit.finish(ctx.dry_run, in_review='error')
+    return {'track': track, 'googleGroups': args.groups, 'dry_run': ctx.dry_run}

mkit/config.py

@@ -0,0 +1,146 @@
+"""Project settings: find mkit.toml, read it, and answer "is this feature on?".
+
+A project is the folder holding mkit.toml. mkit walks up from where it was
+started, so it works from any subfolder of the app, the same way git does.
+
+Settings are layered, first match wins:
+
+    command flags  >  MKIT_* environment  >  <project>/mkit.toml
+                   >  ~/.mkit/config.toml  >  built-in defaults
+
+A table in mkit.toml switches a feature on. `[firebase]` present means this app
+uses Firebase; absent means every Firebase step is skipped without a word, since
+the app simply does not use it. That is how one pipeline serves apps that need
+different parts of it.
+"""
+import os
+import re
+import tomllib
+from dataclasses import dataclass, field
+from pathlib import Path
+
+from . import __version__
+from .errors import MkitError, NotFound, UsageError
+
+PROJECT_FILE = 'mkit.toml'
+KINDS = ('flutter', 'android', 'android-wear')
+
+# Tables that switch a feature on by being present. Order is how doctor lists them.
+FEATURES = ('play', 'store', 'firebase', 'notify.telegram', 'aso', 'art', 'hooks')
+
+
+def home():
+    """User-level folder shared by every project: config.toml and .env."""
+    override = os.environ.get('MKIT_HOME')
+    return Path(override) if override else Path.home() / '.mkit'
+
+
+def find_root(start=None):
+    """The nearest folder at or above `start` that holds mkit.toml, or None."""
+    here = Path(start or os.getcwd()).resolve()
+    for folder in (here, *here.parents):
+        if (folder / PROJECT_FILE).is_file():
+            return folder
+    return None
+
+
+def _read_toml(path):
+    try:
+        with open(path, 'rb') as f:
+            return tomllib.load(f)
+    except tomllib.TOMLDecodeError as e:
+        raise UsageError(f'{path} is not valid TOML: {e}',
+                         hint='Fix the file; `mkit doctor` re-checks it.',
+                         code='BAD_CONFIG') from e
+
+
+def _version_tuple(text):
+    return tuple(int(p) for p in re.findall(r'\d+', text)[:3])
+
+
+def check_requires(spec, have=__version__):
+    """True when the running engine satisfies `requires = ">=x.y"`."""
+    m = re.fullmatch(r'\s*>=\s*([\d.]+)\s*', spec or '')
+    if not m:
+        raise UsageError(f'requires = "{spec}" is not understood',
+                         hint='Use the form requires = ">=0.1".', code='BAD_CONFIG')
+    return _version_tuple(have) >= _version_tuple(m.group(1))
+
+
+def _dig(data, dotted):
+    node = data
+    for part in dotted.split('.'):
+        if not isinstance(node, dict) or part not in node:
+            return None
+        node = node[part]
+    return node
+
+
+@dataclass
+class Project:
+    root: Path
+    data: dict = field(default_factory=dict)
+    user: dict = field(default_factory=dict)
+
+    @property
+    def name(self):
+        return self.get('app.name') or self.root.name
+
+    @property
+    def kind(self):
+        return self.get('app.kind')
+
+    @property
+    def package(self):
+        return self.get('app.package')
+
+    def has(self, feature):
+        """Whether the feature's table is in mkit.toml (the app opted in)."""
+        return isinstance(_dig(self.data, feature), dict)
+
+    def section(self, feature):
+        found = _dig(self.data, feature)
+        return found if isinstance(found, dict) else {}
+
+    def get(self, dotted, default=None):
+        """Environment first (MKIT_APP_PACKAGE for app.package), then the
+        project file, then the user file."""
+        env = os.environ.get('MKIT_' + dotted.replace('.', '_').replace('-', '_').upper())
+        if env is not None:
+            return env
+        for source in (self.data, self.user):
+            value = _dig(source, dotted)
+            if value is not None:
+                return value
+        return default
+
+    def path(self, dotted, default=None):
+        """A project-relative path setting, resolved against the project root."""
+        value = self.get(dotted, default)
+        return (self.root / value) if value else None
+
+
+def load(start=None, project=None):
+    """Load the project containing `start` (or the explicit `project` folder)."""
+    root = Path(project).resolve() if project else find_root(start)
+    if root is None or not (root / PROJECT_FILE).is_file():
+        where = project or os.getcwd()
+        raise NotFound(f'no {PROJECT_FILE} in {where} or any folder above it',
+                       hint='Run `mkit init` in the app folder to create one.',
+                       code='NO_PROJECT')
+    data = _read_toml(root / PROJECT_FILE)
+    user_file = home() / 'config.toml'
+    user = _read_toml(user_file) if user_file.is_file() else {}
+
+    spec = data.get('requires')
+    if spec and not check_requires(spec):
+        raise MkitError(f'this project needs mkit {spec}, but {__version__} is installed',
+                        hint='Run `mkit self update`: it upgrades a git checkout, or names '
+                             'the command for the package manager that installed mkit.',
+                        code='ENGINE_TOO_OLD')
+
+    kind = _dig(data, 'app.kind')
+    if kind is not None and kind not in KINDS:
+        raise UsageError(f'app.kind = "{kind}" is not one of {", ".join(KINDS)}',
+                         code='BAD_CONFIG')
+    return Project(root=root, data=data, user=user)

mkit/data/art/art.toml

@@ -0,0 +1,119 @@
+# Store art for this app, built by `mkit art build` (docs/store-art.md).
+# Paths are relative to the app folder (where mkit.toml is).
+
+layout = "classic"               # "classic" (words over one phone, soft gradient) or "pop"
+                                 # (vivid ground, bold underlined titles, big phones, pills; see below)
+reference = "en"                 # the captions file every language is measured against
+
+font_dir = "assets/fonts"        # holds <font>-Regular/-Medium/-SemiBold/-Bold.ttf
+font = "Barlow"                  # the app's own typeface; draws every Latin-script language
+mascot = "assets/icon/icon_foreground.svg"   # SVG or PNG: hero brand, feature graphic, notification icon
+decoration = "contour"           # classic's backdrop: "contour" (topographic rings), "leaves" (sprigs) or "none"
+
+# The status bar. mode = "redraw" (classic's default): the phone's own icons
+# are erased and a clean 9:41 bar is drawn over the capture. Boxes are [left,
+# top, right, bottom] in capture pixels.
+# mode = "clean" (pop's default): the capture keeps its own bar, painted over
+# up to `height` (default 96) in the colour at `sample`, with a 9:41, signal
+# and battery drawn in dark or light ink to suit it.
+[status_bar]
+height = 100
+erase = [[36, 8, 250, 96], [760, 8, 1048, 96]]
+# mode = "clean"
+# sample = [540, 60]
+
+# Anything private in a capture (an account name, an email) is erased the same way.
+# [shots.home]
+# erase = [[394, 166, 568, 226]]
+
+# Colours, when the app's look differs from the default green. Any key can be left out.
+# [theme.light]
+# bg1 = "#F4F7EF"          # background gradient, top
+# bg2 = "#DCEAD4"          # background gradient, bottom
+# line = "#4E9150"         # contour lines, or the sprigs
+# line_op = 0.20
+# ink = "#1F2A21"          # headline
+# sub = "#4D5C50"          # subline
+# accent = "#2F7A3E"       # [accent] words, brand name
+# tile = "#E3EFDD"         # notification icon tile
+# chip_border = "rgba(78,145,80,.28)"
+# [theme.dark]             # for slides with dark = true
+# bg1 = "#0E1210"
+# bg2 = "#16261A"
+# ink = "#F3F6F1"
+# accent = "#A5D69B"
+#
+# With layout = "pop" the same tables hold pop's colours instead (defaults shown;
+# [theme.dark] defaults to the light ones with bg1/bg2/bg3 = #1F3D29/#122419/#0B140E,
+# bg_mid = 50 and title_shadow = "none"):
+# [theme.light]
+# bg1 = "#55D27E"          # the ground: a radial glow from the top...
+# bg2 = "#26AC52"
+# bg3 = "#168A3E"          # ...to the bottom
+# bg_mid = 48              # where bg2 sits, in percent
+# blob_dark = "#0F7A34"    # soft shade, bottom left
+# blob_light = "#7BE39B"   # soft light, top right
+# glow = "#FFFFFF"         # halo and ring behind the phones, sprigs, dots, chip glass
+# ink = "#FFFFFF"          # titles, the name, chips
+# title_shadow = "0 4px 18px rgba(5,60,25,.25)"
+# underline = "#FFD95A"    # the hand-drawn line under the [word]
+# accent = "#1E9E4A"       # ticks, the go pill, the notification tile
+# pill = "#FFFFFF"         # pills and the notification card
+# pill_ink = "#1B2A1F"
+# shade = "#043214"        # every shadow, at its own strength
+# phone = "#141816"        # the phone frame
+
+# Fallback fonts for other scripts (Windows names), by listing code:
+# [script_fonts]
+# ka = "Sylfaen"
+
+# The screenshots, in Play order (up to 8). Each id needs an entry in every
+# captions file. kind = "landscape" is the 1920x1080 hero with three phones;
+# the rest are 1080x1920 slides with one phone. shot = a file in shots/.
+[[slide]]
+id = "hero"
+kind = "landscape"
+shots = ["detail", "home", "home_dark"]   # left, middle (front), right
+
+[[slide]]
+id = "home"
+shot = "home"
+
+[[slide]]
+id = "alerts"
+shot = "alerts"
+notify = true            # a phone notification card over the phone (captions: notify)
+
+[[slide]]
+id = "detail"
+shot = "detail"
+
+[[slide]]
+id = "home_dark"
+shot = "home_dark"
+dark = true
+
+# offset = 520 on a slide scrolls its shot up by that many capture pixels.
+
+# Pop only: pills and pictures on a slide, in page pixels (left, top);
+# right-to-left pages mirror them. The hero takes them too, and the feature
+# graphic as [[feature.pill]] / [[feature.art]]. In pop the hero fans two or
+# three `shots`, and a slide may set notify_y (the notification card's top, default 600).
+# [[slide.pill]]
+# text = "Lemons"        # literal, never translated (an item named on the capture)...
+# key = "add"            # ...or translated: captions <slide>.pills.add
+# go = true              # the green action pill
+# x = 40
+# y = 1130
+# size = 50              # font size (default 44)
+# rotate = -5
+# [[slide.art]]
+# src = "store/art/mascot.svg"   # PNG or SVG in the app repo
+# x = 760
+# y = 360
+# height = 240
+# rotate = 10
+# z = 6                  # stacking (default 4; phones 1-2, pills 5)
+
+[feature]                # the 1024x500 feature graphic
+shot = "home"            # pop: shots = ["back", "front"] for two phones

mkit/data/art/en.json

@@ -0,0 +1,38 @@
+{
+  "locale": "en-US",
+  "dir": "ltr",
+  "hero": {
+    "name": "My App",
+    "title": "The one line that says what the app is [for you]",
+    "sub": "What it does for people, in about ten words",
+    "chips": ["First feature", "Second feature", "Third feature"]
+  },
+  "home": {
+    "title": "A benefit, not a feature [in bold]",
+    "sub": "One sentence that backs the headline up"
+  },
+  "alerts": {
+    "title": "Never miss [the moment] again",
+    "sub": "What the notification does for them",
+    "notify": {
+      "app": "My App",
+      "when": "now",
+      "title": "The app's real notification title",
+      "body": "The app's real notification text."
+    }
+  },
+  "detail": {
+    "title": "Everything [in one place]",
+    "sub": "What this screen gives them"
+  },
+  "home_dark": {
+    "title": "Easy on the eyes, [day or night]",
+    "sub": "A full dark theme with the same clear view"
+  },
+  "feature": {
+    "name": "My App",
+    "title": "The promise [in five words]",
+    "sub": "The search term people use for this kind of app",
+    "chips": ["First feature", "Second feature", "Third feature"]
+  }
+}