exp-runtime-player 0.5.0__py3-none-any.whl

exp_runtime/platforms/ios.py

@@ -0,0 +1,225 @@
+"""Serial JSON bridge between UIKit and the shared application/presentation.
+
+Swift owns device services only. Imports, menus, hit testing, clocks, game
+sessions, layout and saves all run through the desktop application's code.
+"""
+import json
+from concurrent.futures import Future
+from pathlib import Path
+import shutil
+import tempfile
+from types import SimpleNamespace
+
+from .drawing import Backend, FrameEncoder
+
+_host = None
+_verifying = False
+
+
+class Host:
+    def __init__(self, directory, *, backend=None, library_root=None, check_updates=True):
+        from .. import graphics
+        if backend is None:
+            import exp_platform
+            def font(request):
+                return json.loads(exp_platform.font(json.dumps(request)))
+            backend = Backend(font, Path(__file__).resolve().parents[3] / 'kiwi.png')
+        self.backend = backend
+        graphics.install(backend)
+        # Import after installing the backend: pygame is not bundled on iOS.
+        from ..application import Application
+        self.directory = Path(directory)
+        self.update_future = None
+        self.update_request = None
+        settings = (Path(library_root).parent if library_root is not None else self.directory / 'EXP Runtime') / 'settings.json'
+        self.app = Application(file_picker=self.pick, library_root=library_root, url_opener=self.open_url,
+                               settings_path=settings, update_fetcher=self.fetch_release, check_updates=check_updates)
+        self.encoder = FrameEncoder()
+        self.picker = None
+        self.url = None
+        self.staging = []
+        self.last_active = True
+        self.app.render()
+        self.input_stamp = self._input_stamp()
+        self.generation = 0
+
+    def _input_stamp(self):
+        game = self.app.game if self.app.screen == 'game' else None
+        action = game.session.pending if game else None
+        session = game.session if game else None
+        return (self.app.input_token(), id(game.session) if game else None, game.menu_open if game else False,
+                id(action), action.details.get('page_start') if action else None,
+                (session.scene, session.vm.steps_executed) if session else None)
+
+    def handle_events(self, events):
+        screen = self.app.screen
+        token = self.app.input_token()
+        entry = self.app.game.session.pending if screen == 'game' else None
+        for event in events:
+            if event.get('generation', self.generation) != self.generation:
+                continue  # A touch begun on an expired timed choice cannot answer its successor.
+            self._event(event)
+            if self.app.input_token() != token:
+                break
+            if screen == 'game' and self.app.game.screen_token != self.app.game._screen_token():
+                # Keep all queued characters for this same text field. The
+                # one-input gate still applies when it submits or raises an alert.
+                editing = (entry is not None and entry.name == 'text_input'
+                           and self.app.game.session.pending is entry and not self.app.game.input_error
+                           and (event['kind'] == 'text' or event.get('key') == 'backspace'))
+                if not editing:
+                    break
+
+    def pick(self, kind):
+        self.picker = kind
+
+    def open_url(self, url):
+        self.url = url
+
+    def fetch_release(self):
+        # The host handles HTTPS with URLSession/system certificate trust.
+        # Shared Python still owns versions, settings and the Yes/No prompt.
+        from ..updates import RELEASE_API, REQUEST_HEADERS, TIMEOUT, MAX_RESPONSE
+        self.update_future = Future()
+        self.update_request = dict(url=RELEASE_API, headers=REQUEST_HEADERS,
+                                   timeout=TIMEOUT, max_bytes=MAX_RESPONSE)
+        return self.update_future
+
+    def _event(self, event):
+        b = self.backend
+        kind = event['kind']
+        if kind in ('down', 'up', 'move'):
+            position = tuple(event['point'])
+            b.pointer = position if kind != 'up' else (-1, -1)
+            event = SimpleNamespace(type={'down': b.MOUSEBUTTONDOWN, 'up': b.MOUSEBUTTONUP,
+                                          'move': b.MOUSEMOTION}[kind], pos=position, button=1)
+        elif kind == 'scroll':
+            event = SimpleNamespace(type=b.MOUSEWHEEL, y=event['delta'])
+        elif kind == 'text':
+            event = SimpleNamespace(type=b.TEXTINPUT, text=event['text'])
+        elif kind == 'key':
+            event = SimpleNamespace(type=b.KEYDOWN, key={'return': b.K_RETURN, 'backspace': b.K_BACKSPACE,
+                                                        'escape': b.K_ESCAPE}[event['key']])
+        elif kind == 'cancel':
+            b.pointer = (-1, -1)
+            self.app.cancel_pointer()
+            return
+        else:
+            raise ValueError(f'Unsupported iOS input: {kind}')
+        self.app.handle_event(event)
+
+    def active(self, value):
+        if value == self.last_active:
+            return
+        self.last_active = value
+        b = self.backend
+        self.app.handle_event(SimpleNamespace(type=b.WINDOWFOCUSGAINED if value else b.WINDOWFOCUSLOST))
+        if not value:
+            b.mixer.stop()
+            if self.app.game:
+                self.app._attempt(lambda: self.app.state.checkpoint(self.app.game.session))
+
+    def request(self, message):
+        operation = message.get('operation', 'frame')
+        verification = {}
+        if operation in ('verify_start', 'verify_next'):
+            import exp_ios_probe
+            if operation == 'verify_start':
+                self.test_steps = exp_ios_probe.presentation_steps(self)
+                verification['drawing_test'] = exp_ios_probe.drawing_fixture()
+                verification['audio_test'] = exp_ios_probe.audio_fixture()
+            try:
+                verification['verification_check'] = next(self.test_steps)
+            except StopIteration:
+                verification['verification_done'] = True
+            message = dict(message, elapsed=50)
+        elif operation == 'import':
+            kind = message['kind']
+            paths = [Path(path) for path in message['paths']]
+            if kind == 'library':
+                if len(paths) != 1 or not paths[0].is_dir():
+                    raise ValueError('Choose one EXP Runtime library folder')
+                self.app._attempt(lambda: self.app.open_library(paths[0], remember=True))
+            else:
+                self.app._attempt(lambda: self.app.import_paths(paths))
+                self.staging.extend(paths)
+        elif operation == 'message':
+            self.app.message = message['text']
+        elif operation == 'update_result':
+            if self.update_future is not None and not self.update_future.done():
+                self.update_future.set_result(message.get('payload'))
+            self.update_future = None
+        elif operation == 'active':
+            self.active(bool(message['active']))
+        elif operation == 'close':
+            self.app.close()
+            return {'status': 'closed'}
+        elif operation != 'frame':
+            raise ValueError(f'Unsupported iOS operation: {operation}')
+        elapsed = max(0, int(message.get('elapsed', 0))) if self.last_active else 0
+        self.backend.ticks += elapsed
+        self.handle_events(message.get('events', ()))
+        self.app.tick(elapsed)
+        if not self.app.busy and self.staging:
+            # Swift copied imports into a disposable, app-owned directory.
+            # Never remove a selected original or a library being played.
+            imports = (self.directory / 'Imports').resolve()
+            for path in self.staging:
+                if path.resolve().is_relative_to(imports):
+                    if path.is_dir():
+                        shutil.rmtree(path)
+                    else:
+                        path.unlink(missing_ok=True)
+                    parent = path.parent.resolve()
+                    while parent != imports and parent.is_relative_to(imports):
+                        try:
+                            parent.rmdir()
+                        except OSError:
+                            break
+                        parent = parent.parent
+            self.staging.clear()
+        self.app.render()
+        stamp = self._input_stamp()
+        if stamp != self.input_stamp:
+            self.input_stamp = stamp
+            self.generation += 1
+        frame = self.encoder.encode(self.backend.window)
+        audio, self.backend.mixer.commands = self.backend.mixer.commands, []
+        picker, self.picker = self.picker, None
+        url, self.url = self.url, None
+        update_request, self.update_request = self.update_request, None
+        if self.update_future is None or self.update_future.cancelled():
+            update_request = None
+        game = self.app.game if self.app.screen == 'game' else None
+        pending = game.session.pending if game else None
+        if (operation.startswith('verify_') and verification.get('verification_check')
+                and self.app.screen == 'main' and self.app.menu_music_loaded):
+            verification['verify_menu_audio'] = True
+        if (operation.startswith('verify_')
+                and str(verification.get('verification_check', '')).endswith('menu click')):
+            verification['verify_click_audio'] = True
+        return dict(verification, status='ok', frame=frame, audio=audio, keyboard=self.backend.keyboard, picker=picker, open_url=url,
+                    update_request=update_request,
+                    generation=self.generation,
+                    scrollable=self.app.screen in ('episodes', 'browser') or bool(game and game.max_scroll),
+                    busy=self.app.busy, screen=self.app.screen, game=self.app.selected_game,
+                    pending=pending.name if pending else None, scene=game.session.scene if game else None,
+                    error=game.error if game else self.app.message or None)
+
+
+def request(payload, directory):
+    global _host, _verifying
+    message = json.loads(payload)
+    if message.get('operation') == 'verify':
+        _verifying = True
+        import exp_ios_probe
+        return exp_ios_probe.request(payload, directory)
+    if _host is None:
+        # Launch-argument diagnostics never open or change a player's library.
+        root = None
+        if _verifying:
+            parent = Path(directory) / 'Verification'
+            parent.mkdir(parents=True, exist_ok=True)
+            root = Path(tempfile.mkdtemp(prefix='libraries-', dir=parent))
+        _host = Host(directory, library_root=root, check_updates=not _verifying)
+    return json.dumps(_host.request(message), separators=(',', ':'))

exp_runtime/pointer.py

@@ -0,0 +1,25 @@
+"""Button tracking shared by the desktop and native touch hosts."""
+
+
+class ButtonPress:
+    def __init__(self):
+        self.cancel()
+
+    def cancel(self):
+        self.origin = self.pressed = self.token = None
+
+    def validate(self, token):
+        if self.token != token:
+            self.cancel()
+
+    def update(self, phase, hit, token=None):
+        if phase == 'down':
+            self.origin, self.pressed, self.token = hit, hit, token
+        else:
+            self.validate(token)
+            self.pressed = hit if hit == self.origin else None
+            if phase == 'up':
+                command = self.pressed
+                self.cancel()
+                return command
+        return None

exp_runtime/projection.py

@@ -0,0 +1,68 @@
+"""Perspective texture mapping shared by software and native drawing hosts."""
+from functools import lru_cache
+import math
+
+
+def inverse_quad(points):
+    """Map a convex screen quad to the unit texture square (TL/TR/BR/BL)."""
+    (x0, y0), (x1, y1), (x2, y2), (x3, y3) = points
+    dx1, dx2, dx3 = x1 - x2, x3 - x2, x0 - x1 + x2 - x3
+    dy1, dy2, dy3 = y1 - y2, y3 - y2, y0 - y1 + y2 - y3
+    denominator = dx1 * dy2 - dx2 * dy1
+    if abs(denominator) < 1e-9:
+        return None
+    g = (dx3 * dy2 - dx2 * dy3) / denominator
+    h = (dx1 * dy3 - dx3 * dy1) / denominator
+    a, b, c = x1 - x0 + g * x1, x3 - x0 + h * x3, x0
+    d, e, f = y1 - y0 + g * y1, y3 - y0 + h * y3, y0
+    k = a * e - b * d
+    if abs(k) < 1e-9:
+        return None
+    return tuple(v / k for v in (e - f*h, c*h - b, b*f - c*e,
+                                 f*g - d, a - c*g, c*d - a*f, d*h - e*g, b*g - a*h))
+
+
+def local_map(coefficients, x, y):
+    a, b, c, d, e, f, g, h = coefficients
+    k = g*x + h*y + 1
+    return tuple(v / k for v in (a, b, a*x + b*y + c, d, e, d*x + e*y + f, g, h))
+
+
+def warp(source, size, coefficients):
+    from PIL import Image
+    factors = (source.width,) * 3 + (source.height,) * 3 + (1, 1)
+    return source.transform(size, Image.Transform.PERSPECTIVE,
+                            tuple(v * scale for v, scale in zip(coefficients, factors)),
+                            Image.Resampling.BILINEAR)
+
+
+@lru_cache(maxsize=256)
+def _desktop_texture(image):
+    # Grid face images are immutable cached assets; only their transforms move.
+    from PIL import Image
+    from . import graphics
+    return Image.frombytes('RGBA', image.get_size(), graphics.image.tobytes(image, 'RGBA'))
+
+
+def draw_quad(target, image, points):
+    from . import graphics
+    coefficients = inverse_quad(points)
+    if coefficients is None:
+        return
+    clip = target.get_clip()
+    left = max(clip.left, math.floor(min(p[0] for p in points)))
+    top = max(clip.top, math.floor(min(p[1] for p in points)))
+    right = min(clip.right, math.ceil(max(p[0] for p in points)))
+    bottom = min(clip.bottom, math.ceil(max(p[1] for p in points)))
+    if right <= left or bottom <= top:
+        return
+    coefficients = local_map(coefficients, left, top)
+    bounds = left, top, right - left, bottom - top
+    native = getattr(graphics.draw, 'textured_quad', None)
+    if native is not None:
+        native(target, image, bounds, coefficients)
+    else:
+        pixels = warp(_desktop_texture(image), bounds[2:], coefficients)
+        layer = graphics.image.frombytes(pixels.tobytes(), pixels.size, 'RGBA')
+        layer.set_alpha(image.get_alpha())
+        target.blit(layer, (left, top))

exp_runtime/settings.py

@@ -0,0 +1,46 @@
+"""App-wide preferences, independent of either game's imported library."""
+import json
+import logging
+import os
+from pathlib import Path
+import tempfile
+
+from .launcher import user_data_directory
+
+
+class AppSettings:
+    def __init__(self, path=None):
+        self.path = Path(path) if path is not None else user_data_directory() / 'settings.json'
+        self.check_for_updates = True
+        try:
+            data = json.loads(self.path.read_text(encoding='utf-8'))
+            if (not isinstance(data, dict) or data.get('version') != 1
+                    or type(data.get('check_for_updates')) is not bool):
+                raise ValueError('Invalid application settings')
+            self.check_for_updates = data['check_for_updates']
+        except FileNotFoundError:
+            pass
+        except (OSError, ValueError) as error:
+            # A damaged/unreadable preference must not silently re-enable
+            # networking the player may have disabled.
+            self.check_for_updates = False
+            logging.warning('Could not read application settings: %s', error)
+
+    def set_update_check(self, enabled):
+        if type(enabled) is not bool:
+            raise ValueError('Update preference must be a boolean')
+        self.path.parent.mkdir(parents=True, exist_ok=True)
+        temporary = None
+        try:
+            with tempfile.NamedTemporaryFile(mode='w', encoding='utf-8', dir=self.path.parent,
+                                             prefix='.settings-', delete=False) as stream:
+                temporary = Path(stream.name)
+                json.dump(dict(version=1, check_for_updates=enabled), stream)
+                stream.write('\n')
+                stream.flush()
+                os.fsync(stream.fileno())
+            temporary.replace(self.path)
+            self.check_for_updates = enabled
+        finally:
+            if temporary is not None:
+                temporary.unlink(missing_ok=True)

exp_runtime/updates.py

@@ -0,0 +1,144 @@
+"""One optional, nonblocking public-release check per application launch.
+
+Only metadata is fetched. The browser opens a release page after an explicit
+Yes; this module never downloads, installs or executes release assets.
+"""
+from concurrent.futures import Future
+from dataclasses import dataclass
+from http.client import HTTPException
+import json
+import logging
+import re
+import ssl
+import subprocess
+import sys
+from threading import Thread
+from urllib.error import HTTPError
+from urllib.parse import quote
+from urllib.request import Request, urlopen
+
+from .app_info import PROJECT_REPOSITORY, PROJECT_URL, runtime_version
+
+
+RELEASE_API = f'https://api.github.com/repos/{PROJECT_REPOSITORY}/releases/latest'
+MAX_RESPONSE = 1024 * 1024
+TIMEOUT = 8
+REQUEST_HEADERS = {'Accept': 'application/vnd.github+json',
+                   'X-GitHub-Api-Version': '2022-11-28', 'User-Agent': 'EXP-Runtime-update-check'}
+UPDATE_MESSAGE = 'Update available. Download here.'
+
+
+@dataclass(frozen=True)
+class Release:
+    version: str
+    url: str
+
+
+def _version(text):
+    # Released app versions are three numeric components. Recognize the
+    # project's possible PEP 440 prerelease/dev builds without lexicographic
+    # comparisons (0.10.0 > 0.9.0) or guessing about unknown tag formats.
+    if not isinstance(text, str) or len(text) > 100:
+        return None
+    match = re.fullmatch(r'v?(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)'
+                         r'(?:(a|b|rc)\d+)?(?:\.(dev|post)\d+)?(?:\+[a-zA-Z0-9.-]+)?', text)
+    if match is None:
+        return None
+    return (*map(int, match.group(1, 2, 3)), int(match[4] is None and match[5] != 'dev'))
+
+
+def newer_release(payload, current):
+    installed = _version(current)
+    if installed is None or not isinstance(payload, (str, bytes)) or len(payload) > MAX_RESPONSE:
+        return None
+    try:
+        data = json.loads(payload)
+    except (ValueError, UnicodeError):
+        return None
+    if (not isinstance(data, dict) or data.get('draft') is not False
+            or data.get('prerelease') is not False):
+        return None
+    tag = data.get('tag_name')
+    # The endpoint excludes prereleases; independently require a stable
+    # release tag before constructing a URL on our own project's domain.
+    if not isinstance(tag, str) or re.fullmatch(r'v?\d+\.\d+\.\d+', tag) is None:
+        return None
+    latest = _version(tag)
+    if latest is None or latest <= installed:
+        return None
+    return Release(tag.removeprefix('v'), f'{PROJECT_URL}/releases/tag/{quote(tag, safe="")}')
+
+
+def _ssl_context():
+    context = ssl.create_default_context()
+    if sys.platform == 'darwin':
+        # Frozen macOS apps cannot depend on the build machine's Homebrew
+        # CA path. Read Apple's public root certificates using its system tool.
+        roots = subprocess.run(['/usr/bin/security', 'find-certificate', '-a', '-p',
+                                '/System/Library/Keychains/SystemRootCertificates.keychain'],
+                               check=True, capture_output=True, text=True, timeout=TIMEOUT)
+        context.load_verify_locations(cadata=roots.stdout)
+    return context
+
+
+def fetch_release():
+    """Desktop transport; a daemon worker never delays startup or shutdown."""
+    result = Future()
+
+    def work():
+        payload = None
+        try:
+            request = Request(RELEASE_API, headers=REQUEST_HEADERS)
+            with urlopen(request, timeout=TIMEOUT, context=_ssl_context()) as response:
+                if response.status == 200:
+                    data = response.read(MAX_RESPONSE + 1)
+                    if len(data) <= MAX_RESPONSE:
+                        payload = data
+        except (OSError, ValueError, HTTPException, subprocess.SubprocessError) as error:
+            if isinstance(error, HTTPError):
+                error.close()
+            logging.debug('Update check unavailable: %s', error)
+        # set_running_or_notify_cancel also makes cancellation during shutdown
+        # race-free, without joining a DNS/TLS operation on the UI thread.
+        if result.set_running_or_notify_cancel():
+            result.set_result(payload)
+
+    Thread(target=work, name='exp-update-check', daemon=True).start()
+    return result
+
+
+class UpdateCheck:
+    def __init__(self, fetcher=None, *, current=None):
+        self.fetcher = fetcher or fetch_release
+        self.current = runtime_version() if current is None else current
+        self.started = False
+        self.future = None
+        self.available = None
+
+    def start(self):
+        if self.started or _version(self.current) is None:
+            return
+        self.started = True
+        try:
+            self.future = self.fetcher()
+        except (OSError, RuntimeError) as error:
+            logging.debug('Update check could not start: %s', error)
+
+    def poll(self):
+        if self.future is not None and self.future.done():
+            future, self.future = self.future, None
+            if not future.cancelled():
+                try:
+                    self.available = newer_release(future.result(), self.current)
+                except Exception as error:
+                    logging.debug('Update check unavailable: %s', error)
+        return self.available
+
+    def dismiss(self):
+        self.available = None
+
+    def cancel(self):
+        if self.future is not None:
+            self.future.cancel()
+            self.future = None
+        self.dismiss()

exp_runtime_player-0.5.0.dist-info/METADATA

@@ -0,0 +1,49 @@
+Metadata-Version: 2.4
+Name: exp-runtime-player
+Version: 0.5.0
+Summary: Shared EXP Runtime player and native/desktop rendering
+License: MIT License
+        
+        Copyright (c) 2025 Josh Mcdaniel
+        
+        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.
+        
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: exp-runtime-engine[fonts]==0.5.0
+Provides-Extra: desktop
+Requires-Dist: pygame-ce<3,>=2.5.7; extra == "desktop"
+Dynamic: license-file
+
+# EXP Runtime — player
+
+Shared EXP Runtime player and native/desktop rendering. This is a component of the single
+[EXP Runtime project](https://github.com/joshrmcdaniel/exp-runtime), maintained
+and released together with its other wheels. Python imports use the shared
+`exp_runtime` namespace.
+
+Install `exp-runtime[tools]` for file tools, `exp-runtime[engine,shs]` or
+`exp-runtime[engine,cod]` for a headless game, or `exp-runtime[player]` for
+the desktop player with both games. Individual component wheels also support
+selective installs. See the project's `docs/SDK.md` for APIs and examples.
+
+No original game content is included. Users supply their own game files.
+The inherited MIT license and attribution are included in LICENSE; see
+[provenance](https://github.com/joshrmcdaniel/exp-runtime/blob/main/docs/PROVENANCE.md).

exp_runtime_player-0.5.0.dist-info/RECORD

@@ -0,0 +1,29 @@
+exp_runtime/app_icon.py,sha256=cxZFBiN9KmJK9K-rMfaNxBg_0MGcu5fSvhF95wZ-e6o,394
+exp_runtime/app_info.py,sha256=ES5AesX8Ht1Z230tjOSCQJMVQpZylQ0Thic8iuy4eoE,539
+exp_runtime/application.py,sha256=pLHbjkuae_9xc7gaos017RZvV3Jd2ck2lg-YmdoC1cI,37163
+exp_runtime/desktop.py,sha256=um8WIY1-NcXAjtqwoe2gvE4uio8fDcevPkKm4NZTnFg,39134
+exp_runtime/desktop_choice.py,sha256=Ru6gUtt3kXeXXoIOLZChYM-5Kv4EyS-BCto3o_F7YRw,11501
+exp_runtime/desktop_dialogue.py,sha256=ifnYQ9YcpUL0Pyt6RYrNrfDBDX6U4CTm1RTIbEMaDJE,14215
+exp_runtime/desktop_input.py,sha256=gQMmYCpGx-xN6ED6Sc5ROYIkymt4FxWqVAk3gG642v8,9811
+exp_runtime/desktop_loading.py,sha256=GoFQfteMWDLHYznGcdd9IS7PWsLgOB8spYWFcGid858,2439
+exp_runtime/desktop_menu.py,sha256=P0JT1IRgYBEyPn-MJ3dFZzWUK45ssGI2oVjQLnFP2Dw,26874
+exp_runtime/desktop_message.py,sha256=Cmgl7Jv9HLTVNsHYaHgvhZCmw2GV8FRs4rqXj4luDGY,6706
+exp_runtime/desktop_pause.py,sha256=3RUBo-PXYe3OrlZB_xqHEgcstqsIE57eCNh5j8m7Yzs,5197
+exp_runtime/desktop_picker.py,sha256=LkyIQX2hwncOYcKLW4qWnHuQRBeWaXWVs1cGzKXLUzA,3604
+exp_runtime/desktop_text.py,sha256=36KK2qwcd3z86-HGTvWoo4Id9bM1W1SjJX_aax1Q9C8,4312
+exp_runtime/desktop_title.py,sha256=c8PwFhZWxWlRB1YEBz6dIZVgHXeioevk0ilJ4nu5gdU,3875
+exp_runtime/graphics.py,sha256=1i8_6B-1Ef1bX0qm6xfTdSDTwmj3DZ5eBHBm6-newoQ,2460
+exp_runtime/pointer.py,sha256=smhXTZ9yGhJTID263qSMZUSKhwt6LH-uXvZE_oZ_QLI,706
+exp_runtime/projection.py,sha256=i7WkGPrPOsWyO3OQ44E7eqVrG1WqZpnUk-50Fy5njDc,2680
+exp_runtime/settings.py,sha256=TYPf0nphdai2Gk6Q8mNydu9jb_rfS8uwcubMfoyIjgY,1943
+exp_runtime/updates.py,sha256=S64XNhJM3rHuT9LAjIt0776i-wmDAaej-zx6Uo-OcyI,5437
+exp_runtime/assets/kiwi.svg,sha256=1ecGyaJjPteO9xlsONT3b5ILWO6eq3hvkOeo_XqCtqA,4420
+exp_runtime/platforms/__init__.py,sha256=IEWH1SUQ1uY-djD8Wzhhkm_CV3gUtvlZLN6Ss6tRN9w,74
+exp_runtime/platforms/drawing.py,sha256=OEegHvPNdS-Mnds9stk2J930z2zqz95jnzQUGLigxuw,23464
+exp_runtime/platforms/ios.py,sha256=xbdDXkaqidsH2V_wk72s4VB7Z-9X928SUMyp-Mk8it8,10779
+exp_runtime_player-0.5.0.dist-info/licenses/LICENSE,sha256=y2xxdaMMD9iKqLFR2Lp8sM_0b3qZWxU4_vW0zgufh2k,1070
+exp_runtime_player-0.5.0.dist-info/METADATA,sha256=HsU8bGDLtzkXzVJAhCjDklCuykzMiKLrwCLMnUCnklo,2443
+exp_runtime_player-0.5.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+exp_runtime_player-0.5.0.dist-info/entry_points.txt,sha256=ALTaa-N7w-MrIBrWCV78YNuguS-O8I_hKbgscRXfIt8,92
+exp_runtime_player-0.5.0.dist-info/top_level.txt,sha256=1uRgkxqLAgYpITLluWh9qs6TpAD83zFoh0E5lbic4RA,12
+exp_runtime_player-0.5.0.dist-info/RECORD,,

exp_runtime_player-0.5.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

exp_runtime_player-0.5.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[gui_scripts]
+exp-runtime = exp_runtime.application:main
+shs = exp_runtime.application:main

exp_runtime_player-0.5.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Josh Mcdaniel
+
+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.

exp_runtime_player-0.5.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+exp_runtime