flatpaker 0.0.1__py3-none-any.whl

flatpaker/__init__.py

@@ -0,0 +1,15 @@
+# SPDX-License-Identifier: MIT
+# Copyright © 2024 Dylan Baker
+
+"""Utilities to convert various kinds of native binaries into flatpaks.
+
+Current support includes Ren'Py and some versions of RPGMaker (MV and MZ, when
+they have Linux packages).
+
+Attempts to make some optimizations of the packages, such as recompiling
+bytecode, and patches various games to honor XDG variables, so that flatpaks
+don't need access to the user home directory. This increases security and is
+generally beneficial for end users.
+"""
+
+__version__ = "0.0.1"

flatpaker/config.py

@@ -0,0 +1,38 @@
+# SPDX-License-Identifier: MIT
+# Copyright © 2024 Dylan Baker
+
+from __future__ import annotations
+import os
+import typing
+
+from flatpaker.util import tomllib
+
+if typing.TYPE_CHECKING:
+
+    Common = typing.TypedDict(
+        'Common',
+        {
+            'gpg-key': str,
+            'repo': str,
+        },
+        total=False,
+    )
+
+    class Config(typing.TypedDict):
+        common: Common
+
+
+def load_config() -> Config:
+    root = os.environ.get('XDG_CONFIG_HOME', os.path.expanduser('~/.config'))
+    conf = os.path.join(root, 'flatpaker', 'config.toml')
+    raw: typing.Dict[str, typing.Any]
+    if os.path.exists(conf):
+        with open(conf, 'rb') as f:
+            raw = tomllib.load(f)
+        assert isinstance(raw, dict), 'invalid config file?'
+    else:
+        raw = {}
+
+    if 'common' not in raw:
+        raw['common'] = {}
+    return typing.cast('Config', raw)

flatpaker/entry.py

@@ -0,0 +1,58 @@
+# SPDX-License-Identifier: MIT
+# Copyright © 2022-2024 Dylan Baker
+
+from __future__ import annotations
+import argparse
+import importlib
+import pathlib
+import typing
+
+import flatpaker.config
+import flatpaker.util
+
+if typing.TYPE_CHECKING:
+    JsonWriterImpl = typing.Callable[[flatpaker.util.Description, pathlib.Path, str, pathlib.Path, pathlib.Path], None]
+
+    class ImplMod(typing.Protocol):
+
+        write_rules: JsonWriterImpl
+
+
+def select_impl(name: typing.Literal['renpy', 'rpgmaker']) -> JsonWriterImpl:
+    mod = typing.cast('ImplMod', importlib.import_module(name, 'flatpaker.impl'))
+    assert hasattr(mod, 'write_rules'), 'should be good enough'
+    return mod.write_rules
+
+
+def main() -> None:
+    config = flatpaker.config.load_config()
+    parser = argparse.ArgumentParser()
+    parser.add_argument('description', help="A Toml description file")
+    parser.add_argument(
+        '--repo',
+        default=config['common'].get('repo', 'repo'),
+        action='store',
+        help='a flatpak repo to put the result in')
+    parser.add_argument(
+        '--gpg',
+        default=config['common'].get('gpg-key'),
+        action='store',
+        help='A GPG key to sign the output to when writing to a repo')
+    parser.add_argument('--export', action='store_true', help='Export to the provided repo')
+    parser.add_argument('--install', action='store_true', help="Install for the user (useful for testing)")
+    parser.add_argument('--no-cleanup', action='store_false', dest='cleanup', help="don't delete the temporary directory")
+    args = typing.cast('flatpaker.util.Arguments', parser.parse_args())
+    # Don't use type for this because it swallows up the exception
+    description = flatpaker.util.load_description(args.description)
+
+    # TODO: This could be common
+    appid = f"{description['common']['reverse_url']}.{flatpaker.util.sanitize_name(description['common']['name'])}"
+
+    write_build_rules = select_impl(description['common']['engine'])
+
+    with flatpaker.util.tmpdir(description['common']['name'], args.cleanup) as d:
+        wd = pathlib.Path(d)
+        desktop_file = flatpaker.util.create_desktop(description, wd, appid)
+        appdata_file = flatpaker.util.create_appdata(description, wd, appid)
+        write_build_rules(description, wd, appid, desktop_file, appdata_file)
+        flatpaker.util.build_flatpak(args, wd, appid)

flatpaker/impl/renpy.py

@@ -0,0 +1,191 @@
+# SPDX-License-Identifier: MIT
+# Copyright © 2022-2024 Dylan Baker
+
+from __future__ import annotations
+import json
+import os
+import pathlib
+import textwrap
+import typing
+
+from flatpaker import util
+
+
+def _create_game_sh(use_x11: bool) -> str:
+    lines: typing.List[str] = [
+        '#!/usr/bin/env sh',
+        '',
+        'export RENPY_PERFORMANCE_TEST=0',
+    ]
+
+    if not use_x11:
+        lines.append('export SDL_VIDEODRIVER=wayland')
+
+    lines.extend([
+        'cd /app/lib/game',
+        'exec sh *.sh',
+    ])
+
+    return '\n'.join(lines)
+
+
+def quote(s: str) -> str:
+    return f'"{s}"'
+
+
+def bd_game(description: util.Description) -> typing.Dict[str, typing.Any]:
+    sh = _create_game_sh(description.get('workarounds', {}).get('use_x11', True))
+    return {
+        'buildsystem': 'simple',
+        'name': 'game_sh',
+        'sources': [],
+        'build-commands': [
+            'mkdir -p /app/bin',
+            f"echo '{sh}' > /app/bin/game.sh",
+            'chmod +x /app/bin/game.sh'
+        ],
+    }
+
+
+def bd_build_commands(description: util.Description) -> typing.List[str]:
+    commands: typing.List[str] = [
+        'mkdir -p /app/lib/game',
+
+        # install the main game files
+        'mv *.sh *.py renpy game lib /app/lib/game/',
+
+        # Move archives that have not been strippped as they would conflict
+        # with the main source archive
+        'cp -r */game/* /app/lib/game/game/ || true',
+    ]
+
+    # Insert these commands before any rpy and py files are compiled
+    for p in description.get('sources', {}).get('files', []):
+        dest = os.path.join('/app/lib/game', p.get('dest', 'game'))
+        commands.extend([
+            f'mkdir -p {os.path.dirname(dest)}',
+            f'mv {p["path"].name} {dest}',
+        ])
+
+    commands.extend([
+        # Patch the game to not require sandbox access
+        '''sed -i 's@"~/.renpy/"@os.environ.get("XDG_DATA_HOME", "~/.local/share") + "/"@g' /app/lib/game/*.py''',
+
+        # Recompile all of the rpy files
+        textwrap.dedent('''
+            pushd /app/lib/game;
+            script="$PWD/$(ls *.sh)";
+            dirs="$(find . -type f -name '*.rpy' -printf '%h\\0' | sort -zu | sed -z 's@$@ @')";
+            for d in $dirs; do
+                bash $script $d compile --keep-orphan-rpyc;
+            done;
+            popd;
+            '''),
+
+        # Recompile all python py files, so we can remove the py files
+        # form the final distribution
+        #
+        # Use -f to force the files mtimes to be updated, otherwise
+        # flatpak-builder will delete them as "stale"
+        #
+        # Use -b for python3 to allow us to delete the .py files
+        # I have run into a couple of python2 based ren'py programs that lack
+        # the python infrastructure to run with -m, so we'll just open code it to
+        # make it more portable
+        textwrap.dedent('''
+            pushd /app/lib/game;
+            if [ -d "lib/py3-linux-x86_64" ]; then
+                lib/py3-linux-x86_64/python -m compileall -b -f . || exit 1;
+            else
+                lib/linux-x86_64/python -c 'import compileall; compileall.main()' -f . || exit 1;
+            fi;
+            popd;
+            ''')
+    ])
+
+    return commands
+
+
+def bd_icon(description: util.Description, appid: str) -> typing.Dict[str, typing.Any]:
+    icon_src = '/app/lib/game/game/gui/window_icon.png'
+    icon_dst = f'/app/share/icons/hicolor/256x256/apps/{appid}.png'
+    # Must at least be before the appdata is generated
+
+    _icon_install_cmd: str
+    if description.get('workarounds', {}).get('icon_is_webp'):
+        _icon_install_cmd = f'dwebp {icon_src} -o {icon_dst}'
+    else:
+        _icon_install_cmd = f'cp {icon_src} {icon_dst}'
+
+    return {
+        'buildsystem': 'simple',
+        'name': 'icon',
+        'sources': [],
+        'build-commands': [
+            'mkdir -p /app/share/icons/hicolor/256x256/apps/',
+            _icon_install_cmd,
+        ],
+    }
+
+
+def write_rules(description: util.Description, workdir: pathlib.Path, appid: str, desktop_file: pathlib.Path, appdata_file: pathlib.Path) -> None:
+    sources = util.extract_sources(description)
+
+    # TODO: typing requires more thought
+    modules: typing.List[typing.Dict[str, typing.Any]] = [
+        {
+            'buildsystem': 'simple',
+            'name': util.sanitize_name(description['common']['name']),
+            'sources': sources,
+            'build-commands': bd_build_commands(description),
+            'cleanup': [
+                '*.exe',
+                '*.app',
+                '*.rpyc.bak',
+                '*.txt',
+                '*.rpy',
+                '/lib/game/lib/*darwin-*',
+                '/lib/game/lib/*windows-*',
+                '/lib/game/lib/*-i686',
+            ],
+        },
+    ]
+    if not description.get('workarounds', {}).get('icon', False):
+        modules.append(bd_icon(description, appid))
+    modules.extend([
+        bd_game(description),
+        util.bd_desktop(desktop_file),
+        util.bd_appdata(appdata_file),
+    ])
+
+    if description.get('workarounds', {}).get('use_x11', True):
+        finish_args = ['--socket=x11']
+    else:
+        finish_args = ['--socket=wayland', '--socket=fallback-x11']
+
+    struct = {
+        'sdk': 'org.freedesktop.Sdk',
+        'runtime': 'org.freedesktop.Platform',
+        'runtime-version': util.RUNTIME_VERSION,
+        'id': appid,
+        'build-options': {
+            'no-debuginfo': True,
+            'strip': False
+        },
+        'command': 'game.sh',
+        'finish-args': [
+            *finish_args,
+            '--socket=pulseaudio',
+            '--device=dri',
+        ],
+        'modules': modules,
+        'cleanup-commands': [
+            "find /app/lib/game/game -name '*.py' -delete",
+            "find /app/lib/game/lib -name '*.py' -delete",
+            "find /app/lib/game/renpy -name '*.py' -delete",
+            'find /app/lib/game -name __pycache__ -print | xargs -n1 rm -vrf',
+        ]
+    }
+
+    with (pathlib.Path(workdir) / f'{appid}.json').open('w') as f:
+        json.dump(struct, f, indent=4)

flatpaker/impl/rpgmaker.py

@@ -0,0 +1,75 @@
+# SPDX-License-Identifier: MIT
+# Copyright © 2022-2024 Dylan Baker
+
+from __future__ import annotations
+import json
+import pathlib
+import typing
+
+import flatpaker.util as util
+
+
+def write_rules(description: util.Description, workdir: pathlib.Path, appid: str, desktop_file: pathlib.Path, appdata_file: pathlib.Path) -> None:
+    sources = util.extract_sources(description)
+
+    # TODO: typing requires more thought
+    modules: typing.List[typing.Dict[str, typing.Any]] = [
+        {
+            'buildsystem': 'simple',
+            'name': util.sanitize_name(description['common']['name']),
+            'sources': sources,
+            'build-commands': [
+                'mkdir -p /app/share/icons/hicolor/256x256/apps/',
+                f'mv icon/*.png /app/share/icons/hicolor/256x256/apps/{appid}.png',
+                'rm -r icon',
+
+                # the main executable usually isn't executable
+                'chmod +x nw',
+
+                # Likewise, but seem to only exist for RPGMaker MZ, not MV
+                '[[ -f "chrome_crashpad_handler" ]] && chmod +x chrome_crashpad_handler',
+                '[[ -f "nacl_helper" ]] && chmod +x nacl_helper',
+
+                # install the main game files
+                'mkdir -p /app/lib/game',
+                'mv * /app/lib/game/',
+            ],
+            'cleanup': [
+                '*.desktop',  # is incorrect
+            ],
+        },
+        {
+            'buildsystem': 'simple',
+            'name': 'game_sh',
+            'sources': [],
+            'build-commands': [
+                'mkdir -p /app/bin',
+                'echo  \'exec /app/lib/game/nw\' > /app/bin/game.sh',
+                'chmod +x /app/bin/game.sh',
+            ],
+        },
+        util.bd_desktop(desktop_file),
+        util.bd_appdata(appdata_file),
+    ]
+
+    # TODO: share this somehow?
+    struct = {
+        'sdk': 'org.freedesktop.Sdk',
+        'runtime': 'org.freedesktop.Platform',
+        'runtime-version': util.RUNTIME_VERSION,
+        'id': appid,
+        'build-options': {
+            'no-debuginfo': True,
+            'strip': False
+        },
+        'command': 'game.sh',
+        'finish-args': [
+            '--socket=pulseaudio',
+            '--socket=x11',
+            '--device=dri',
+        ],
+        'modules': modules,
+    }
+
+    with (pathlib.Path(workdir) / f'{appid}.json').open('w') as f:
+        json.dump(struct, f)

flatpaker/util.py

@@ -0,0 +1,263 @@
+# SPDX-License-Identifier: MIT
+# Copyright © 2022-2024 Dylan Baker
+
+from __future__ import annotations
+from xml.etree import ElementTree as ET
+import contextlib
+import hashlib
+import pathlib
+import shutil
+import subprocess
+import tempfile
+import textwrap
+import typing
+
+try:
+    import tomllib as tomllib
+except ImportError:
+    import tomli as tomllib  # type: ignore[import-not-found,no-redef]
+
+if typing.TYPE_CHECKING:
+    from typing_extensions import NotRequired
+
+    class Arguments(typing.Protocol):
+        description: str
+        repo: str
+        gpg: typing.Optional[str]
+        install: bool
+        export: bool
+        cleanup: bool
+
+    class _Common(typing.TypedDict):
+
+        reverse_url: str
+        name: str
+        engine: typing.Literal['renpy', 'rpgmaker']
+        categories: NotRequired[typing.List[str]]
+
+    class _AppData(typing.TypedDict):
+
+        summary: str
+        description: str
+        content_rating: NotRequired[typing.Dict[str, typing.Literal['none', 'mild', 'moderate', 'intense']]]
+        releases: NotRequired[typing.Dict[str, str]]
+        license: NotRequired[str]
+
+    class _Workarounds(typing.TypedDict, total=False):
+        icon: bool
+        icon_is_webp: bool
+        use_x11: bool
+
+    class Archive(typing.TypedDict):
+
+        path: pathlib.Path
+        strip_components: NotRequired[int]
+
+    class File(typing.TypedDict):
+
+        path: pathlib.Path
+        dest: NotRequired[str]
+
+    class Sources(typing.TypedDict):
+
+        archives: typing.List[Archive]
+        files: NotRequired[typing.List[File]]
+        patches: NotRequired[typing.List[Archive]]
+
+    class Description(typing.TypedDict):
+
+        common: _Common
+        appdata: _AppData
+        workarounds: NotRequired[_Workarounds]
+        sources: NotRequired[Sources]
+
+RUNTIME_VERSION = "24.08"
+
+
+def _subelem(elem: ET.Element, tag: str, text: typing.Optional[str] = None, **extra: str) -> ET.Element:
+    new = ET.SubElement(elem, tag, extra)
+    new.text = text
+    return new
+
+
+def extract_sources(description: Description) -> typing.List[typing.Dict[str, object]]:
+    sources: typing.List[typing.Dict[str, object]] = []
+
+    if 'sources' in description:
+        for a in description['sources']['archives']:
+            sources.append({
+                'path': a['path'].as_posix(),
+                'sha256': sha256(a['path']),
+                'type': 'archive',
+                'strip-components': a.get('strip_components', 1),
+            })
+        for source in description['sources'].get('files', []):
+            p = source['path']
+            sources.append({
+                'path': p.as_posix(),
+                'sha256': sha256(p),
+                'type': 'file',
+            })
+        for a in description['sources'].get('patches', []):
+            sources.append({
+                'type': 'patch',
+                'path': a['path'].as_posix(),
+                'strip-components': a.get('strip_components', 1),
+            })
+
+    return sources
+
+
+def create_appdata(description: Description, workdir: pathlib.Path, appid: str) -> pathlib.Path:
+    p = workdir / f'{appid}.metainfo.xml'
+
+    root = ET.Element('component', type="desktop-application")
+    _subelem(root, 'id', appid)
+    _subelem(root, 'name', description['common']['name'])
+    _subelem(root, 'summary', description['appdata']['summary'])
+    _subelem(root, 'metadata_license', 'CC0-1.0')
+    _subelem(root, 'project_license', description['appdata'].get('license', 'LicenseRef-Proprietary'))
+
+    recommends = ET.SubElement(root, 'recommends')
+    for c in ['pointing', 'keyboard', 'touch', 'gamepad']:
+        _subelem(recommends, 'control', c)
+
+    requires = ET.SubElement(root, 'requires')
+    _subelem(requires, 'display_length', '360', compare="ge")
+    _subelem(requires, 'internet', 'offline-only')
+
+    categories = ET.SubElement(root, 'categories')
+    for c in ['Game'] + description['common'].get('categories', []):
+        _subelem(categories, 'category', c)
+
+    desc = ET.SubElement(root, 'description')
+    _subelem(desc, 'p', description['appdata']['description'])
+    _subelem(root, 'launchable', f'{appid}.desktop', type="desktop-id")
+
+    # There is an oars-1.1, but it doesn't appear to be supported by KDE
+    # discover yet
+    if 'content_rating' in description['appdata']:
+        cr = ET.SubElement(root, 'content_rating', type="oars-1.0")
+        for k, r in description['appdata']['content_rating'].items():
+            _subelem(cr, 'content_attribute', r, id=k)
+
+    if 'releases' in description['appdata']:
+        cr = ET.SubElement(root, 'releases')
+        for date, version in description['appdata']['releases'].items():
+            _subelem(cr, 'release', version=version, date=date)
+
+    tree = ET.ElementTree(root)
+    ET.indent(tree)
+    tree.write(p, encoding='utf-8', xml_declaration=True)
+
+    return p
+
+
+def create_desktop(description: Description, workdir: pathlib.Path, appid: str) -> pathlib.Path:
+    p = workdir / f'{appid}.desktop'
+    with p.open('w') as f:
+        f.write(textwrap.dedent(f'''\
+            [Desktop Entry]
+            Name={description['common']['name']}
+            Exec=game.sh
+            Type=Application
+            Categories={';'.join(['Game'] + description['common'].get('categories', []))};
+            '''))
+        if description.get('workarounds', {}).get('icon', True):
+            f.write(f'Icon={appid}')
+
+    return p
+
+
+def sha256(path: pathlib.Path) -> str:
+    with path.open('rb') as f:
+        return hashlib.sha256(f.read()).hexdigest()
+
+
+def sanitize_name(name: str) -> str:
+    """Replace invalid characters in a name with valid ones."""
+    return name \
+        .replace(' ', '_') \
+        .replace("&", '_') \
+        .replace(':', '') \
+        .replace("'", '')
+
+
+def build_flatpak(args: Arguments, workdir: pathlib.Path, appid: str) -> None:
+    build_command: typing.List[str] = [
+        'flatpak-builder', '--force-clean', '--install-deps-from=flathub', '--user', 'build',
+        (workdir / f'{appid}.json').absolute().as_posix(),
+    ]
+
+    if args.export:
+        build_command.extend(['--repo', args.repo])
+        if args.gpg:
+            build_command.extend(['--gpg-sign', args.gpg])
+    if args.install:
+        build_command.extend(['--install'])
+
+    subprocess.run(build_command)
+
+
+def load_description(name: str) -> Description:
+    relpath = pathlib.Path(name).parent.absolute()
+    with open(name, 'rb') as f:
+        d = typing.cast('Description', tomllib.load(f))
+
+    # Fixup relative paths
+    if 'sources' in d:
+        for a in d['sources']['archives']:
+            a['path'] = relpath / a['path']
+        if 'files' in d['sources']:
+            for s in d['sources']['files']:
+                s['path'] = relpath / s['path']
+        if 'patches' in d['sources']:
+            for a in d['sources']['patches']:
+                a['path'] = relpath / a['path']
+
+    return d
+
+
+@contextlib.contextmanager
+def tmpdir(name: str, cleanup: bool = True) -> typing.Iterator[pathlib.Path]:
+    tdir = pathlib.Path(tempfile.gettempdir()) / name
+    tdir.mkdir(parents=True, exist_ok=True)
+    yield tdir
+    if cleanup:
+        shutil.rmtree(tdir)
+
+
+def bd_desktop(file_: pathlib.Path) -> typing.Dict[str, typing.Any]:
+    return {
+        'buildsystem': 'simple',
+        'name': 'desktop_file',
+        'sources': [
+            {
+                'path': file_.as_posix(),
+                'sha256': sha256(file_),
+                'type': 'file',
+            }
+        ],
+        'build-commands': [
+            'mkdir -p /app/share/applications',
+            f'cp {file_.name} /app/share/applications',
+        ],
+    }
+
+
+def bd_appdata(file_: pathlib.Path) -> typing.Dict[str, typing.Any]:
+    return {
+        'buildsystem': 'simple',
+        'name': 'appdata_file',
+        'sources': [
+            {
+                'path': file_.as_posix(),
+                'sha256': sha256(file_),
+                'type': 'file',
+            }
+        ],
+        'build-commands': [
+            'mkdir -p /app/share/metainfo',
+            f'cp {file_.name} /app/share/metainfo',
+        ],
+    }

flatpaker-0.0.1.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Dylan Baker
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

flatpaker-0.0.1.dist-info/METADATA

@@ -0,0 +1,150 @@
+Metadata-Version: 2.1
+Name: flatpaker
+Version: 0.0.1
+Summary: Utilities to convert various kinds of native binaries into flatpaks.
+Keywords: flatpak,renpy,rpgmaker
+Author-email: Dylan Baker <dylan@pnwbakers.com>
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: System :: Archiving :: Packaging
+Requires-Dist: tomli; python_version<"3.11"
+
+# flatpaker
+
+Script to mostly automate creating flatpaks from published Ren'Py and Linux
+builds of RPGMaker MV and MZ. open to additional support
+
+## What is it?
+
+It's a script that automatically handles much of the task of generating a
+flatpak for pre-built projects, including adding patches or mods. You
+write a small, simple toml file, fetch the sources, and get a ready to publish
+flatpak.
+
+It currently automatically does the following automatically:
+
+- Generates an appstream xml file
+- Generates a .desktop file
+- Extracts an icon from the game source, and installs it
+- patches the game to honor $XDG_DATA_HOME for storing game data inside the sandbox (instead of needing $HOME access)
+- sets up the sandbox to allow audio and display, but nothing else
+- recompiles the program when mods are applied
+- strips .rpy files to save space (keeping the rpyc files)
+- strips windows and macos specific files
+- allows local install or publishing to a repo
+
+## Why?
+
+I like playing Ren'Py games sometimes. I also don't always trust random
+pre-compiled binaries from the internet. Flatpak provides a nice, convenient
+way to sandbox applications. It also makes supporting Steam Deck and Fedora
+immutable a breeze. But generating flatpaks by hand is a lot of work, especially
+when most of the process will be exactly the same for every renpy project.
+
+## How do I use it?
+
+1. Download the compressed project
+2. Download any mods or addons (optional)
+3. Write a toml description
+4. run the program
+
+### Toml Format
+
+```toml
+[common]
+  name = 'Game or VN'  # use properly formatted name like "The Cool Adventures of Bob", or "Bob's Quest 7: Lawnmower Confusion"
+  reverse_url = 'com.example.JDoe'  # name will be appended
+  # "Game" is added automatically
+  # used freedesktop menu categories. see: https://specifications.freedesktop.org/menu-spec/latest/apas02.html
+  categories = ['Simulation']
+  engine = ['renpy']  # Or 'rpgmaker'
+
+[appdata]
+  summary = "A short summary, one sentence or so."
+  description = """
+    A longer description.
+
+    probably on multiple \
+    lines
+    """
+
+  # This is an optional value for the license of the renpy project itself.
+  # If unset it defaults to LicenseRef-Proprietary.
+  # if you have specific terms which are not an Open Source license, you can use the form:
+  # LicenseRef-Proprietary=https://www.example.com/my-license
+  # See: https://spdx.org/specifications for more information
+  license = "SPDX identifier"
+
+[appdata.content_rating]
+  # optional
+  # Uses OARS specifications. See: https://hughsie.github.io/oars/
+  # keys should be ids, and the values are must be a rating (as a string):
+  # none, mild, moderate, or intense
+  language-profanity = "mild"
+
+[appdata.releases]
+  # optional
+  # in the form "date = version"
+  "2023-01-01" = "1.0.0"
+
+# Optional, alternatively may be passed on teh command line
+[[sources.archives]]
+  # path must be set if this is provided
+  path = "relative to toml or absolute path"
+
+  # Optional, defaults to 1. How many directory levels to remove from this component
+  strip_comonents = 2
+
+# Optional, cannot be set from command line
+[[sources.patches]]
+  # path must be set if this is provided
+  path = "relative to toml or absolute path"
+
+  # Optional, defaults to 1. How many directory levels to remove from this component
+  strip_comonents = 2
+
+# Optional, cannot be set from command line
+[[sources.files]]
+  # path must be set if this is provided
+  path = "relative to toml or absolute path"
+
+  # Optional, if set the file will be installed to this name
+  # Does not have to be set for .rpy files that go in the game root directory
+  dest = "where to install"
+```
+
+### Configuration
+
+Some options can be given on the command line or via a configuration file.
+That file must be written to `$XDG_CONFIG_HOME/flatpaker/config.toml` (if unset
+`$XDG_CONFIG_HOME` defaults to `~/.config`).
+
+```toml
+[common]
+  # A gpg private key to sign with, overwritten by the --gpg option
+  gpg-key = "0x123456789"
+
+  # The absolute path to a repo to write to. overwritten by the --repo option
+  repo = "/path/to/a/repo/to/export"
+```
+
+
+## What is required?
+
+- python 3.11 or a modern version of python3 with tomli
+- flatpak-builder
+
+### Schema
+
+A Json based schema is provided, which can be used with VSCode's EvenBetterToml
+extension. It may be useful elsewhere.
+

flatpaker-0.0.1.dist-info/RECORD

@@ -0,0 +1,12 @@
+flatpaker/__init__.py,sha256=PsGR5gs45aoJvPD1NHYiyPzrqGJjlynQgcPzUULvCZs,534
+flatpaker/config.py,sha256=z3GFLh3It1qM1W_Brds1AjFojPDjqswPrxdGxkp7T94,882
+flatpaker/entry.py,sha256=u4o6U3rz75b-5M8pRJ0SeW5V3zXSYoGvcyeY8Jvq18c,2370
+flatpaker/util.py,sha256=Ulx6VKzVNEz_v2U5x5ORZnX6gaN0190H_WYSTk6JV8I,8105
+flatpaker/impl/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+flatpaker/impl/renpy.py,sha256=LooyGP4qM8-uwEtkRSpqAyxgEa805_wabc6D1SnfsAU,6076
+flatpaker/impl/rpgmaker.py,sha256=Kvy6Mb_iOjD-AmUfJphyvFUnJzIBxWYoGoEIAsrx7kk,2392
+flatpaker-0.0.1.dist-info/entry_points.txt,sha256=_6R4HPhjK68ou2LtVSgm26ltyMaQF4tCQT-L9ymdOgQ,50
+flatpaker-0.0.1.dist-info/LICENSE,sha256=QqvRDZzvUrvgv6CnNh5LdWCnoF19JuPUYzE-Qs8pNFY,1068
+flatpaker-0.0.1.dist-info/WHEEL,sha256=EZbGkh7Ie4PoZfRQ8I0ZuP9VklN_TvcZ6DSE5Uar4z4,81
+flatpaker-0.0.1.dist-info/METADATA,sha256=awJgom54TVC5npmCQob03mQNnOLw0YsV1w0HJHmXAe0,5149
+flatpaker-0.0.1.dist-info/RECORD,,

flatpaker-0.0.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: flit 3.9.0
+Root-Is-Purelib: true
+Tag: py3-none-any

flatpaker-0.0.1.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+flatpaker=flatpaker.entry:main
+