This is a simple example of a hybrid application using PPG.
14 | 15 | 16 | 25 | 26 | 27 | 28 | 29 | 30 | 76 | 77 | 78 | -------------------------------------------------------------------------------- /ppg_runtime/licensing.py: -------------------------------------------------------------------------------- 1 | from base64 import b64encode, b64decode 2 | from rsa import PrivateKey, PublicKey, VerificationError 3 | 4 | import json 5 | import rsa 6 | 7 | def pack_license_key(data, privkey_args): 8 | """ 9 | Pack a dictionary of license key data to a string. You typically call this 10 | function on a server, when a user purchases a license. Eg.: 11 | 12 | lk_contents = pack_license_key({'email': 'some@user.com'}, ...) 13 | 14 | The parameter `privkey_args` is a dictionary containing values for the RSA 15 | fields "n", "e", "d", "p" and "q". You can generate it with ppg's command 16 | `init_licensing`. 17 | 18 | The resulting string is signed to prevent the end user from changing it. 19 | Use the function `unpack_license_key` below to reconstruct `data` from it. 20 | This also verifies that the string was not tampered with. 21 | 22 | This function has two non-obvious caveats: 23 | 24 | 1) It does not obfuscate the data. If `data` contains "key": "value", then 25 | "key": "value" is also visible in the resulting string. 26 | 27 | 2) Calling this function twice with the same arguments will result in the 28 | same string. This may be undesirable when you generate multiple license keys 29 | for the same user. A simple workaround for this is to add a unique parameter 30 | to `data`, such as the current timestamp. 31 | """ 32 | data_bytes = _dumpb(data) 33 | signature = rsa.sign(data_bytes, PrivateKey(**privkey_args), 'SHA-1') 34 | result = dict(data) 35 | if 'key' in data: 36 | raise ValueError('Data must not contain an element called "key"') 37 | result['key'] = b64encode(signature).decode('ascii') 38 | return json.dumps(result) 39 | 40 | class _Licensing: 41 | """ 42 | This internal class lets us inject the licensing functionality into the 43 | application context, in such a way that the ppg user does not have to worry 44 | about where the public key is stored. 45 | """ 46 | def __init__(self, pubkey_args): 47 | self._pubkey = pubkey_args 48 | def unpack_license_key(self, key_str): 49 | return unpack_license_key(key_str, self._pubkey) 50 | 51 | class InvalidKey(Exception): 52 | pass 53 | 54 | def unpack_license_key(key_str, pubkey_args): 55 | """ 56 | Decode a string of license key data produced by `pack_license_key`. In other 57 | words, this function is the inverse of `pack_...` above: 58 | 59 | data == unpack_license_key(pack_license_key(data, ...), ...) 60 | 61 | If the given string is not a valid key, `InvalidKey` is raised. 62 | 63 | The parameter `pubkey_args` is a dictionary containing values for the RSA 64 | fields "n" and "e". It can be generated with ppg's command `init_licensing`. 65 | """ 66 | try: 67 | result = json.loads(key_str) 68 | except ValueError: 69 | raise InvalidKey() from None 70 | try: 71 | signature = result.pop('key') 72 | except KeyError: 73 | raise InvalidKey() from None 74 | try: 75 | signature_bytes = b64decode(signature.encode('ascii')) 76 | except ValueError: 77 | raise InvalidKey() from None 78 | try: 79 | rsa.verify(_dumpb(result), signature_bytes, PublicKey(**pubkey_args)) 80 | except VerificationError: 81 | raise InvalidKey() from None 82 | return result 83 | 84 | def _dumpb(dict_): 85 | return json.dumps(dict_, sort_keys=True).encode('utf-8') -------------------------------------------------------------------------------- /ppg/cmdline.py: -------------------------------------------------------------------------------- 1 | from argparse import ArgumentParser 2 | from ppg._state import COMMANDS 3 | from ppg_runtime import FbsError 4 | from inspect import getfullargspec 5 | from os import getcwd 6 | from os.path import basename, splitext 7 | 8 | import ppg 9 | import logging 10 | import sys 11 | 12 | _LOG = logging.getLogger(__name__) 13 | 14 | def main(project_dir=None): 15 | """ 16 | This function is executed when you run `ppg ...` on the command line. You 17 | can call this function from your own build script to run ppg as if it were 18 | called via the above command. For an example, see: 19 | https://build-system.fman.io/manual/#custom-commands 20 | """ 21 | if project_dir is None: 22 | project_dir = getcwd() 23 | try: 24 | ppg.init(project_dir) 25 | # Load built-in commands: 26 | from ppg import builtin_commands 27 | from ppg.builtin_commands import _docker 28 | from ppg.builtin_commands import _gpg 29 | from ppg.builtin_commands import _account 30 | from ppg.builtin_commands import _licensing 31 | fn, args = _parse_cmdline() 32 | fn(*args) 33 | except KeyboardInterrupt: 34 | print('') 35 | sys.exit(-1) 36 | except FbsError as e: 37 | # Don't print a stack trace for FbsErrors, just their message: 38 | _LOG.error(str(e)) 39 | sys.exit(-1) 40 | 41 | def command(f): 42 | """ 43 | Use this as a decorator to define custom ppg commands. For an example, see: 44 | https://build-system.fman.io/manual/#custom-commands 45 | """ 46 | COMMANDS[f.__name__] = f 47 | return f 48 | 49 | def _parse_cmdline(): 50 | parser = _get_cmdline_parser() 51 | args = parser.parse_args() 52 | if hasattr(args, 'fn'): 53 | fn_args = [] 54 | for arg in args.args[:1-len(args.defaults)]: 55 | fn_args.append(getattr(args, arg)) 56 | for arg, default in zip(args.args[-len(args.defaults):], args.defaults): 57 | fn_args.append(getattr(args, arg, default)) 58 | return args.fn, fn_args 59 | return parser.print_help, () 60 | 61 | def _get_cmdline_parser(): 62 | # Were we invoked with `python -m ppg`? 63 | is_python_m_fbs = splitext(basename(sys.argv[0]))[0] == '__main__' 64 | if is_python_m_fbs: 65 | prog = '%s -m ppg' % basename(sys.executable) 66 | else: 67 | prog = None 68 | parser = ArgumentParser(prog=prog, description='ppg') 69 | subparsers = parser.add_subparsers() 70 | for cmd_name, cmd_fn in COMMANDS.items(): 71 | cmd_parser = subparsers.add_parser(cmd_name, help=cmd_fn.__doc__) 72 | argspec = getfullargspec(cmd_fn) 73 | args = argspec.args or [] 74 | defaults = argspec.defaults or () 75 | args_without_defaults = args[:1-len(defaults)] 76 | args_with_defaults = args[-len(defaults):] 77 | for arg in args_without_defaults: 78 | cmd_parser.add_argument(arg) 79 | for arg, default in zip(args_with_defaults, defaults): 80 | if isinstance(default, bool): 81 | cmd_parser.add_argument( 82 | '--' + arg, action='store_' + str(not default).lower() 83 | ) 84 | else: 85 | type_ = None if default is None else type(default) 86 | cmd_parser.add_argument(arg, default=default, type=type_) 87 | cmd_parser.set_defaults(fn=cmd_fn, args=args, defaults=defaults) 88 | return parser -------------------------------------------------------------------------------- /ppg/installer/linux.py: -------------------------------------------------------------------------------- 1 | from ppg import path, SETTINGS 2 | from ppg.installer import _generate_installer_resources 3 | from ppg.resources import get_icons 4 | from ppg_runtime.platform import is_arch_linux 5 | from os import makedirs, remove, rename 6 | from os.path import join, dirname, exists 7 | from shutil import copy, rmtree, copytree 8 | from subprocess import run, DEVNULL 9 | 10 | def generate_installer_files(): 11 | if exists(path('target/installer')): 12 | rmtree(path('target/installer')) 13 | copytree(path('${freeze_dir}'), path('target/installer/opt/${app_name}')) 14 | _generate_installer_resources() 15 | # Special handling of the .desktop file: Replace AppName by actual name. 16 | apps_dir = path('target/installer/usr/share/applications') 17 | rename( 18 | join(apps_dir, 'AppName.desktop'), 19 | join(apps_dir, SETTINGS['app_name'] + '.desktop') 20 | ) 21 | _generate_icons() 22 | 23 | def run_fpm(output_type): 24 | dest = path('target/${installer}') 25 | if exists(dest): 26 | remove(dest) 27 | # Lower-case the name to avoid the following fpm warning: 28 | # > Debian tools (dpkg/apt) don't do well with packages that use capital 29 | # > letters in the name. In some cases it will automatically downcase 30 | # > them, in others it will not. It is confusing. Best to not use any 31 | # > capital letters at all. 32 | name = SETTINGS['app_name'].lower() 33 | args = [ 34 | 'fpm', '-s', 'dir', 35 | # We set the log level to error because fpm prints the following warning 36 | # even if we don't have anything in /etc: 37 | # > Debian packaging tools generally labels all files in /etc as config 38 | # > files, as mandated by policy, so fpm defaults to this behavior for 39 | # > deb packages. You can disable this default behavior with 40 | # > --deb-no-default-config-files flag 41 | '--log', 'error', 42 | '-C', path('target/installer'), 43 | '-n', name, 44 | '-v', SETTINGS['version'], 45 | '--vendor', SETTINGS['author'], 46 | '-t', output_type, 47 | '-p', dest 48 | ] 49 | if SETTINGS['description']: 50 | args.extend(['--description', SETTINGS['description']]) 51 | if SETTINGS['author_email']: 52 | args.extend([ 53 | '-m', '%s <%s>' % (SETTINGS['author'], SETTINGS['author_email']) 54 | ]) 55 | if SETTINGS['url']: 56 | args.extend(['--url', SETTINGS['url']]) 57 | for dependency in SETTINGS['depends']: 58 | args.extend(['-d', dependency]) 59 | if is_arch_linux(): 60 | for opt_dependency in SETTINGS['depends_opt']: 61 | args.extend(['--pacman-optional-depends', opt_dependency]) 62 | try: 63 | run(args, check=True, stdout=DEVNULL) 64 | except FileNotFoundError: 65 | raise FileNotFoundError( 66 | "ppg could not find executable 'fpm'. Please install fpm using the " 67 | "instructions at " 68 | "https://fpm.readthedocs.io/en/latest/installing.html." 69 | ) from None 70 | 71 | def _generate_icons(): 72 | dest_root = path('target/installer/usr/share/icons/hicolor') 73 | makedirs(dest_root) 74 | icons_fname = '%s.png' % SETTINGS['app_name'] 75 | for size, _, icon_path in get_icons(): 76 | icon_dest = join(dest_root, '%dx%d' % (size, size), 'apps', icons_fname) 77 | makedirs(dirname(icon_dest)) 78 | copy(icon_path, icon_dest) -------------------------------------------------------------------------------- /ppg_runtime/ReactiveWidgets/slider.py: -------------------------------------------------------------------------------- 1 | try: 2 | from PySide6.QtWidgets import QSlider 3 | from PySide6.QtCore import Qt 4 | except ImportError: 5 | try: 6 | from PySide2.QtWidgets import QSlider 7 | from PySide2.QtCore import Qt 8 | except ImportError: 9 | try: 10 | from PyQt6.QtWidgets import QSlider 11 | from PyQt6.QtCore import Qt 12 | except ImportError: 13 | try: 14 | from PyQt5.QtWidgets import QSlider 15 | from PyQt5.QtCore import Qt 16 | except ImportError: 17 | raise ImportError("No Qt bindings found.") 18 | 19 | 20 | class ReactiveSlider(QSlider): 21 | """ 22 | Reactive QSlider connected to Pydux, including support for nested models. 23 | 24 | Args: 25 | parent: Parent widget that contains the store. 26 | key: Key in the store (can be nested, e.g., "settings.volume"). 27 | orientation: Slider orientation (Qt.Horizontal by default). 28 | onChange: Optional callback when value changes. 29 | minimum: Minimum slider value (default 0). 30 | maximum: Maximum slider value (default 100). 31 | """ 32 | def __init__(self, parent, key, orientation=None, onChange=None, minimum=0, maximum=100, **kwargs): 33 | orientation = orientation or Qt.Horizontal 34 | super().__init__(orientation, parent, **kwargs) 35 | self._store_key = key 36 | self._parent = parent 37 | self._updating_from_store = False 38 | self._onChange = onChange 39 | 40 | self.setRange(minimum, maximum) 41 | 42 | # Initialize value from store (supports nested) 43 | if hasattr(parent, "get_nested"): 44 | value = parent.get_nested(key) or minimum 45 | else: 46 | value = parent.store.get(key, minimum) 47 | self.setValue(int(value)) 48 | 49 | # Connect signals 50 | self.valueChanged.connect(self._on_value_changed) 51 | 52 | # Subscribe to store changes 53 | if hasattr(parent, "subscribe_to_store"): 54 | parent.subscribe_to_store(self) 55 | 56 | def _on_value_changed(self, value): 57 | """ 58 | Internal callback when the slider value changes. 59 | Updates the store (supports nested). 60 | """ 61 | if self._updating_from_store: 62 | return 63 | 64 | if "." in self._store_key and hasattr(self._parent, "update_nested_model"): 65 | model_key, nested_field = self._store_key.split(".", 1) 66 | self._parent.update_nested_model(model_key, {nested_field: value}) 67 | else: 68 | self._parent.update_store({self._store_key: value}) 69 | 70 | if callable(self._onChange): 71 | self._onChange(value) 72 | 73 | def _update_from_store(self): 74 | """ 75 | Syncs the slider value with the store. 76 | Supports nested keys using get_nested(). 77 | """ 78 | if hasattr(self._parent, "get_nested"): 79 | value = self._parent.get_nested(self._store_key) or self.minimum() 80 | else: 81 | value = self._parent.store.get(self._store_key, self.minimum()) 82 | 83 | value = int(value) 84 | if self.value() != value: 85 | self._updating_from_store = True 86 | self.setValue(value) 87 | self._updating_from_store = False 88 | 89 | def on_store_change(self, store): 90 | """ 91 | Method automatically called when the store changes. 92 | Simply refreshes the slider value from the store. 93 | """ 94 | self._update_from_store() 95 | -------------------------------------------------------------------------------- /ppg/freeze/__init__.py: -------------------------------------------------------------------------------- 1 | from ppg import path, SETTINGS 2 | from ppg._state import LOADED_PROFILES 3 | from ppg.resources import _copy 4 | from ppg_runtime._fbs import filter_public_settings 5 | from ppg_runtime._source import default_path 6 | from ppg_runtime.platform import is_mac 7 | from os import rename, makedirs 8 | from os.path import join, dirname 9 | from pathlib import PurePath 10 | from subprocess import run 11 | 12 | import ppg_runtime._frozen 13 | 14 | def run_pyinstaller(extra_args=None, debug=False): 15 | if extra_args is None: 16 | extra_args = [] 17 | app_name = SETTINGS['app_name'] 18 | # Would like log level WARN when not debugging. This works fine for 19 | # PyInstaller 3.3. However, for 3.4, it gives confusing warnings 20 | # "hidden import not found". So use ERROR instead. 21 | log_level = 'DEBUG' if debug else 'ERROR' 22 | args = [ 23 | 'pyinstaller', 24 | '--name', app_name, 25 | '--noupx', 26 | '--log-level', log_level, 27 | '--noconfirm' 28 | ] 29 | for hidden_import in SETTINGS['hidden_imports']: 30 | args.extend(['--hidden-import', hidden_import]) 31 | args.extend(SETTINGS.get('extra_pyinstaller_args', [])) 32 | args.extend(extra_args) 33 | args.extend([ 34 | '--distpath', path('target'), 35 | '--specpath', path('target/PyInstaller'), 36 | '--workpath', path('target/PyInstaller') 37 | ]) 38 | args.extend(['--additional-hooks-dir', join(dirname(__file__), 'hooks')]) 39 | if debug: 40 | args.extend(['--debug', 'all']) 41 | if is_mac(): 42 | # Force generation of an .app bundle. Otherwise, PyInstaller skips 43 | # it when --debug is given. 44 | args.append('-w') 45 | hook_path = _generate_runtime_hook() 46 | args.extend(['--runtime-hook', hook_path]) 47 | args.append(path(SETTINGS['main_module'])) 48 | run(args, check=True) 49 | output_dir = path('target/' + app_name + ('.app' if is_mac() else '')) 50 | freeze_dir = path('${freeze_dir}') 51 | # In most cases, rename(src, dst) silently "works" when src == dst. But on 52 | # some Windows drives, it raises a FileExistsError. So check src != dst: 53 | if PurePath(output_dir) != PurePath(freeze_dir): 54 | rename(output_dir, freeze_dir) 55 | 56 | def _generate_runtime_hook(): 57 | makedirs(path('target/PyInstaller'), exist_ok=True) 58 | module = ppg_runtime._frozen 59 | hook_path = path('target/PyInstaller/fbs_pyinstaller_hook.py') 60 | with open(hook_path, 'w') as f: 61 | # Inject public settings such as "version" into the binary, so 62 | # they're available at run time: 63 | f.write('\n'.join([ 64 | 'import importlib', 65 | 'module = importlib.import_module(%r)' % module.__name__, 66 | 'module.BUILD_SETTINGS = %r' % filter_public_settings(SETTINGS) 67 | ])) 68 | return hook_path 69 | 70 | def _generate_resources(): 71 | """ 72 | Copy the data files from src/main/resources to ${freeze_dir}. 73 | Automatically filters files mentioned in the setting files_to_filter: 74 | Placeholders such as ${app_name} are automatically replaced by the 75 | corresponding setting in files on that list. 76 | """ 77 | freeze_dir = path('${freeze_dir}') 78 | if is_mac(): 79 | resources_dest_dir = join(freeze_dir, 'Contents', 'Resources') 80 | else: 81 | resources_dest_dir = freeze_dir 82 | for path_fn in default_path, path: 83 | for profile in LOADED_PROFILES: 84 | _copy(path_fn, 'src/main/resources/' + profile, resources_dest_dir) 85 | _copy(path_fn, 'src/freeze/' + profile, freeze_dir) -------------------------------------------------------------------------------- /ppg_runtime/excepthook/sentry.py: -------------------------------------------------------------------------------- 1 | from ppg_runtime.excepthook import ExceptionHandler 2 | from ppg_runtime.excepthook._util import RateLimiter 3 | 4 | import sentry_sdk 5 | 6 | class SentryExceptionHandler(ExceptionHandler): 7 | """ 8 | Send stack traces to Sentry. For instructions on how to set this up, see: 9 | 10 | https://build-system.fman.io/manual/#error-tracking 11 | 12 | A property of interest in this class is .scope: It lets you send additional 13 | context information to Sentry, such as the user's operating system, or their 14 | email. These data are then displayed alongside any stack traces in Sentry. 15 | 16 | A limitation of .scope is that it is only available once .init() was called. 17 | fbs's ApplicationContext performs this call automatically for handlers 18 | listed in the .exception_handlers property. 19 | 20 | The recommended way for setting context information is to use the `callback` 21 | parameter. You can see its use near the bottom of the following snippet: 22 | 23 | from fbs_runtime import platform 24 | from fbs_runtime.application_context import ApplicationContext, \ 25 | cached_property, is_frozen 26 | 27 | class AppContext(ApplicationContext): 28 | ... 29 | @cached_property 30 | def exception_handlers(self): 31 | result = super().exception_handlers 32 | if is_frozen(): 33 | result.append(self.sentry) 34 | return result 35 | @cached_property 36 | def sentry(self): 37 | # The Sentry client key. Eg. https://4e78a0...@sentry.io/12345. 38 | dsn = self.build_settings['sentry_dsn'] 39 | # Your app version. Eg. 1.2.3: 40 | version = self.build_settings['version'] 41 | # The environment in which your app is running. "local" by 42 | # default, but set to "production" when you do `fbs release`. 43 | environment = self.build_settings['environment'] 44 | return SentryExceptionHandler( 45 | dsn, version, environment, callback=self._on_sentry_init 46 | ) 47 | def _on_sentry_init(self): 48 | self.sentry.scope.set_extra('os', platform.name()) 49 | self.sentry.scope.user = {'id': 41, 'email': 'john@gmail.com'} 50 | 51 | The optional `rate_limit` parameter to the constructor lets you limit the 52 | number of requests per minute. It is there to prevent a single client from 53 | clogging up your Sentry logs. 54 | """ 55 | def __init__( 56 | self, dsn, app_version, environment, callback=lambda: None, 57 | rate_limit=10 58 | ): 59 | super().__init__() 60 | self.scope = None 61 | self._dsn = dsn 62 | self._app_version = app_version 63 | self._environment = environment 64 | self._callback = callback 65 | self._rate_limiter = RateLimiter(60, rate_limit) 66 | def init(self): 67 | sentry_sdk.init( 68 | self._dsn, release=self._app_version, environment=self._environment, 69 | attach_stacktrace=True, default_integrations=False 70 | ) 71 | # Sentry doesn't give us an easy way to set context information 72 | # globally, for all threads. We work around this by maintaining a 73 | # reference to "the" main scope: 74 | self.scope = sentry_sdk.configure_scope().__enter__() 75 | self._callback() 76 | def handle(self, exc_type, exc_value, enriched_tb): 77 | if self._rate_limiter.please(): 78 | sentry_sdk.capture_exception((exc_type, exc_value, enriched_tb)) -------------------------------------------------------------------------------- /ppg/_defaults/src/installer/windows/Installer.nsi: -------------------------------------------------------------------------------- 1 | !include MUI2.nsh 2 | !include FileFunc.nsh 3 | !define MUI_ICON "..\${app_name}\Icon.ico" 4 | !define MUI_UNICON "..\${app_name}\Icon.ico" 5 | 6 | !getdllversion "..\${app_name}\${app_name}.exe" ver 7 | !define VERSION "${ver1}.${ver2}.${ver3}.${ver4}" 8 | 9 | VIProductVersion "${VERSION}" 10 | VIAddVersionKey "ProductName" "${app_name}" 11 | VIAddVersionKey "FileVersion" "${VERSION}" 12 | VIAddVersionKey "ProductVersion" "${VERSION}" 13 | VIAddVersionKey "LegalCopyright" "(C) ${author}" 14 | VIAddVersionKey "FileDescription" "${app_name}" 15 | 16 | ;-------------------------------- 17 | ;Perform Machine-level install, if possible 18 | 19 | !define MULTIUSER_EXECUTIONLEVEL Highest 20 | ;Add support for command-line args that let uninstaller know whether to 21 | ;uninstall machine- or user installation: 22 | !define MULTIUSER_INSTALLMODE_COMMANDLINE 23 | !include MultiUser.nsh 24 | !include LogicLib.nsh 25 | 26 | Function .onInit 27 | !insertmacro MULTIUSER_INIT 28 | ;Do not use InstallDir at all so we can detect empty $InstDir! 29 | ${If} $InstDir == "" ; /D not used 30 | ${If} $MultiUser.InstallMode == "AllUsers" 31 | StrCpy $InstDir "$PROGRAMFILES\${app_name}" 32 | ${Else} 33 | StrCpy $InstDir "$LOCALAPPDATA\${app_name}" 34 | ${EndIf} 35 | ${EndIf} 36 | FunctionEnd 37 | 38 | Function un.onInit 39 | !insertmacro MULTIUSER_UNINIT 40 | FunctionEnd 41 | 42 | ;-------------------------------- 43 | ;General 44 | 45 | Name "${app_name}" 46 | OutFile "..\${installer}" 47 | 48 | ;-------------------------------- 49 | ;Interface Settings 50 | 51 | !define MUI_ABORTWARNING 52 | 53 | ;-------------------------------- 54 | ;Pages 55 | 56 | !define MUI_WELCOMEPAGE_TEXT "This wizard will guide you through the installation of ${app_name}.$\r$\n$\r$\n$\r$\nClick Next to continue." 57 | !insertmacro MUI_PAGE_WELCOME 58 | !insertmacro MUI_PAGE_DIRECTORY 59 | !insertmacro MUI_PAGE_INSTFILES 60 | !define MUI_FINISHPAGE_NOAUTOCLOSE 61 | !define MUI_FINISHPAGE_RUN 62 | !define MUI_FINISHPAGE_RUN_CHECKED 63 | !define MUI_FINISHPAGE_RUN_TEXT "Run ${app_name}" 64 | !define MUI_FINISHPAGE_RUN_FUNCTION "LaunchAsNonAdmin" 65 | !insertmacro MUI_PAGE_FINISH 66 | 67 | !insertmacro MUI_UNPAGE_CONFIRM 68 | !insertmacro MUI_UNPAGE_INSTFILES 69 | 70 | ;-------------------------------- 71 | ;Languages 72 | 73 | !insertmacro MUI_LANGUAGE "English" 74 | 75 | ;-------------------------------- 76 | ;Installer Sections 77 | 78 | !define UNINST_KEY \ 79 | "Software\Microsoft\Windows\CurrentVersion\Uninstall\${app_name}" 80 | Section 81 | SetOutPath "$InstDir" 82 | File /r "..\${app_name}\*" 83 | WriteRegStr SHCTX "Software\${app_name}" "" $InstDir 84 | WriteUninstaller "$InstDir\uninstall.exe" 85 | CreateShortCut "$SMPROGRAMS\${app_name}.lnk" "$InstDir\${app_name}.exe" 86 | WriteRegStr SHCTX "${UNINST_KEY}" "DisplayName" "${app_name}" 87 | WriteRegStr SHCTX "${UNINST_KEY}" "UninstallString" \ 88 | "$\"$InstDir\uninstall.exe$\" /$MultiUser.InstallMode" 89 | WriteRegStr SHCTX "${UNINST_KEY}" "QuietUninstallString" \ 90 | "$\"$InstDir\uninstall.exe$\" /$MultiUser.InstallMode /S" 91 | WriteRegStr SHCTX "${UNINST_KEY}" "Publisher" "${author}" 92 | WriteRegStr SHCTX "${UNINST_KEY}" "DisplayIcon" "$InstDir\uninstall.exe" 93 | ${GetSize} "$InstDir" "/S=0K" $0 $1 $2 94 | IntFmt $0 "0x%08X" $0 95 | WriteRegDWORD SHCTX "${UNINST_KEY}" "EstimatedSize" "$0" 96 | 97 | SectionEnd 98 | 99 | ;-------------------------------- 100 | ;Uninstaller Section 101 | 102 | Section "Uninstall" 103 | 104 | RMDir /r "$InstDir" 105 | Delete "$SMPROGRAMS\${app_name}.lnk" 106 | DeleteRegKey /ifempty SHCTX "Software\${app_name}" 107 | DeleteRegKey SHCTX "${UNINST_KEY}" 108 | 109 | SectionEnd 110 | 111 | Function LaunchAsNonAdmin 112 | Exec '"$WINDIR\explorer.exe" "$InstDir\${app_name}.exe"' 113 | FunctionEnd -------------------------------------------------------------------------------- /ppg/builtin_commands/_docker.py: -------------------------------------------------------------------------------- 1 | from ppg import path, SETTINGS 2 | from ppg.builtin_commands import require_existing_project 3 | from ppg.cmdline import command 4 | from ppg.resources import _copy 5 | from ppg_runtime import FbsError 6 | from ppg_runtime._source import default_path 7 | from os import listdir 8 | from os.path import exists 9 | from shutil import rmtree 10 | from subprocess import run, CalledProcessError, PIPE 11 | 12 | import logging 13 | 14 | __all__ = ['buildvm', 'runvm'] 15 | 16 | _LOG = logging.getLogger(__name__) 17 | 18 | @command 19 | def buildvm(name): 20 | """ 21 | Build a Linux VM. Eg.: buildvm ubuntu 22 | """ 23 | require_existing_project() 24 | build_dir = path('target/%s-docker-image' % name) 25 | if exists(build_dir): 26 | rmtree(build_dir) 27 | src_root = 'src/build/docker' 28 | available_vms = set(listdir(default_path(src_root))) 29 | if exists(path(src_root)): 30 | available_vms.update(listdir(path(src_root))) 31 | if name not in available_vms: 32 | raise FbsError( 33 | 'Could not find %s. Available VMs are:%s' % 34 | (name, ''.join(['\n * ' + vm for vm in available_vms])) 35 | ) 36 | src_dir = src_root + '/' + name 37 | for path_fn in default_path, path: 38 | _copy(path_fn, src_dir, build_dir) 39 | settings = SETTINGS['docker_images'].get(name, {}) 40 | for path_fn in default_path, path: 41 | for p in settings.get('build_files', []): 42 | _copy(path_fn, p, build_dir) 43 | args = ['build', '--pull', '-t', _get_docker_id(name), build_dir] 44 | for arg, value in settings.get('build_args', {}).items(): 45 | args.extend(['--build-arg', '%s=%s' % (arg, value)]) 46 | try: 47 | _run_docker( 48 | args, check=True, stdout=PIPE, stderr=PIPE, 49 | universal_newlines=True 50 | ) 51 | except CalledProcessError as e: 52 | if '/private-key.gpg: no such file or directory' in e.stderr: 53 | message = 'Could not find private-key.gpg. Maybe you want to ' \ 54 | 'run:\n ppg gengpgkey' 55 | else: 56 | message = e.stdout + '\n' + e.stderr 57 | raise FbsError(message) 58 | _LOG.info('Done. You can now execute:\n ppg runvm ' + name) 59 | 60 | @command 61 | def runvm(name): 62 | """ 63 | Run a Linux VM. Eg.: runvm ubuntu 64 | """ 65 | args = ['run', '-it'] 66 | for item in _get_docker_mounts(name).items(): 67 | args.extend(['-v', '%s:%s' % item]) 68 | docker_id = _get_docker_id(name) 69 | args.append(docker_id) 70 | try: 71 | _run_docker(args, stderr=PIPE, universal_newlines=True, check=True) 72 | except CalledProcessError as e: 73 | if 'Unable to find image' in e.stderr: 74 | raise FbsError( 75 | 'Docker could not find image %s. You may want to run:\n' 76 | ' ppg buildvm %s' % (docker_id, name) 77 | ) 78 | 79 | def _run_docker(args, **kwargs): 80 | try: 81 | return run(['docker'] + args, **kwargs) 82 | except FileNotFoundError: 83 | raise FbsError( 84 | 'ppg could not find Docker. Is it installed and on your PATH?' 85 | ) 86 | 87 | def _get_docker_id(name): 88 | prefix = SETTINGS['app_name'].replace(' ', '_').lower() 89 | suffix = name.lower() 90 | return prefix + '/' + suffix 91 | 92 | def _get_docker_mounts(name): 93 | result = {'target/' + name.lower(): 'target'} 94 | # These directories are created inside the container by `buildvm`: 95 | ignore = {'target', 'venv'} 96 | for file_name in listdir(path('.')): 97 | if file_name in ignore: 98 | continue 99 | result[file_name] = file_name 100 | path_in_docker = lambda p: '/root/%s/%s' % (SETTINGS['app_name'], p) 101 | return {path(src): path_in_docker(dest) for src, dest in result.items()} 102 | 103 | def _get_settings(name): 104 | return SETTINGS['docker_images'][name] -------------------------------------------------------------------------------- /ppg_runtime/ReactiveWidgets/combo_box.py: -------------------------------------------------------------------------------- 1 | try: 2 | from PySide6.QtWidgets import QComboBox 3 | except ImportError: 4 | try: 5 | from PySide2.QtWidgets import QComboBox 6 | except ImportError: 7 | try: 8 | from PyQt6.QtWidgets import QComboBox 9 | except ImportError: 10 | try: 11 | from PyQt5.QtWidgets import QComboBox 12 | except ImportError: 13 | raise ImportError("No Qt bindings found.") 14 | 15 | 16 | class ReactiveComboBox(QComboBox): 17 | """ 18 | Reactive QComboBox connected to Pydux, including support for nested models. 19 | 20 | Args: 21 | parent: Parent widget that contains the store. 22 | key: Key in the store for the selection (can be nested, e.g., "user.country"). 23 | items: Fixed list of options (optional). 24 | dynamic_items: Key in the store that provides a dynamic list of options (optional). 25 | onChange: Optional callback when selection changes. 26 | """ 27 | def __init__(self, parent, key, items=None, dynamic_items=None, onChange=None, **kwargs): 28 | super().__init__(parent, **kwargs) 29 | self._parent = parent 30 | self._store_key = key 31 | self._items_key = dynamic_items 32 | self._onChange = onChange 33 | self._updating_from_store = False 34 | 35 | # Load initial items 36 | self._static_items = items or [] 37 | self._update_items() 38 | 39 | # Set initial selection from store 40 | value = self._parent.get_nested(key) or "" 41 | if value in self._get_items(): 42 | self.setCurrentText(str(value)) 43 | 44 | # Connect signal for selection change 45 | self.currentTextChanged.connect(self._on_text_changed) 46 | 47 | # Subscribe to store changes if parent supports it 48 | if hasattr(parent, "subscribe_to_store"): 49 | parent.subscribe_to_store(self) 50 | 51 | def _get_items(self): 52 | """Returns current list of items (dynamic from store if items_key is defined).""" 53 | if self._items_key: 54 | dynamic_list = self._parent.get_nested(self._items_key) 55 | if isinstance(dynamic_list, list): 56 | return dynamic_list 57 | return self._static_items 58 | 59 | def _update_items(self): 60 | """Updates ComboBox items from store or fixed list.""" 61 | current = self.currentText() 62 | self.blockSignals(True) 63 | self.clear() 64 | self.addItems([str(i) for i in self._get_items()]) 65 | # Restore selection if still exists 66 | if current in self._get_items(): 67 | self.setCurrentText(current) 68 | self.blockSignals(False) 69 | 70 | def _on_text_changed(self, text): 71 | """ 72 | Internal callback when ComboBox selection changes. 73 | Updates the store (supports nested keys). 74 | """ 75 | if self._updating_from_store: 76 | return 77 | 78 | if "." in self._store_key: 79 | model_key, nested_field = self._store_key.split(".", 1) 80 | if hasattr(self._parent, "update_nested_model"): 81 | self._parent.update_nested_model(model_key, {nested_field: text}) 82 | else: 83 | self._parent.update_store({self._store_key: text}) 84 | 85 | if callable(self._onChange): 86 | self._onChange(text) 87 | 88 | def _update_from_store(self): 89 | """Synchronizes ComboBox selection and items with the store.""" 90 | # Update items if dynamic items key is defined 91 | if self._items_key: 92 | self._update_items() 93 | # Update selection 94 | value = str(self._parent.get_nested(self._store_key) or "") 95 | if self.currentText() != value: 96 | self._updating_from_store = True 97 | self.setCurrentText(value) 98 | self._updating_from_store = False 99 | 100 | def on_store_change(self, store): 101 | """Method automatically called when the store changes.""" 102 | self._update_from_store() 103 | -------------------------------------------------------------------------------- /ppg/freeze/windows.py: -------------------------------------------------------------------------------- 1 | from ppg import path, SETTINGS 2 | from ppg.freeze import run_pyinstaller, _generate_resources 3 | from ppg.resources import _copy 4 | from ppg_runtime._source import default_path 5 | from os import remove 6 | from os.path import join, exists 7 | from shutil import copy 8 | 9 | import os 10 | import struct 11 | import sys 12 | 13 | def freeze_windows(debug=False): 14 | args = [] 15 | if not (debug or SETTINGS['show_console_window']): 16 | # The --windowed flag below prevents us from seeing any console output. 17 | # We therefore only add it when we're not debugging. 18 | args.append('--windowed') 19 | args.extend(['--icon', path('src/main/icons/Icon.ico')]) 20 | for path_fn in default_path, path: 21 | _copy(path_fn, 'src/freeze/windows/version_info.py', path('target/PyInstaller')) 22 | args.extend(['--version-file', path('target/PyInstaller/version_info.py')]) 23 | run_pyinstaller(args, debug) 24 | _restore_corrupted_python_dlls() 25 | _generate_resources() 26 | copy(path('src/main/icons/Icon.ico'), path('${freeze_dir}')) 27 | _add_missing_dlls() 28 | 29 | def _restore_corrupted_python_dlls(): 30 | # PyInstaller <= 3.4 somehow corrupts python3*.dll - see: 31 | # https://github.com/pyinstaller/pyinstaller/issues/2526 32 | # Restore the uncorrupted original: 33 | python_dlls = ( 34 | 'python%s.dll' % sys.version_info.major, 35 | 'python%s%s.dll' % (sys.version_info.major, sys.version_info.minor) 36 | ) 37 | for dll_name in python_dlls: 38 | try: 39 | remove(path('${freeze_dir}/' + dll_name)) 40 | except FileNotFoundError: 41 | pass 42 | else: 43 | copy(_find_on_path(dll_name), path('${freeze_dir}')) 44 | 45 | def _add_missing_dlls(): 46 | for dll_name in ( 47 | 'msvcr100.dll', 'msvcr110.dll', 'msvcp110.dll', 'vcruntime140.dll', 48 | 'msvcp140.dll', 'concrt140.dll', 'vccorlib140.dll' 49 | ): 50 | try: 51 | _add_missing_dll(dll_name) 52 | except LookupError: 53 | raise FileNotFoundError( 54 | "Could not find %s on your PATH. Please install the Visual C++ " 55 | "Redistributable for Visual Studio 2012 from:\n " 56 | "https://www.microsoft.com/en-us/download/details.aspx?id=30679" 57 | % dll_name 58 | ) from None 59 | for ucrt_dll in ('api-ms-win-crt-multibyte-l1-1-0.dll',): 60 | try: 61 | _add_missing_dll(ucrt_dll) 62 | except LookupError: 63 | bitness_32_or_64 = struct.calcsize("P") * 8 64 | raise FileNotFoundError( 65 | "Could not find %s on your PATH. If you are on Windows 10, you " 66 | "may have to install the Windows 10 SDK from " 67 | "https://developer.microsoft.com/en-us/windows/downloads/windows-10-sdk. " 68 | "Otherwise, try installing KB2999226 from " 69 | "https://support.microsoft.com/en-us/kb/2999226. " 70 | "In both cases, add the directory containing %s to your PATH " 71 | "environment variable afterwards. If there are 32 and 64 bit " 72 | "versions of the DLL, use the %s bit one (because that's the " 73 | "bitness of your current Python interpreter)." % ( 74 | ucrt_dll, ucrt_dll, bitness_32_or_64 75 | ) 76 | ) from None 77 | 78 | def _add_missing_dll(dll_name): 79 | freeze_dir = path('${freeze_dir}') 80 | if not exists(join(freeze_dir, dll_name)): 81 | copy(_find_on_path(dll_name), freeze_dir) 82 | 83 | def _find_on_path(file_name): 84 | path = os.environ.get("PATH", os.defpath) 85 | path_items = path.split(os.pathsep) 86 | if sys.platform == "win32": 87 | if not os.curdir in path_items: 88 | path_items.insert(0, os.curdir) 89 | seen = set() 90 | for dir_ in path_items: 91 | normdir = os.path.normcase(dir_) 92 | if not normdir in seen: 93 | seen.add(normdir) 94 | file_path = join(dir_, file_name) 95 | if exists(file_path): 96 | return file_path 97 | raise LookupError("Could not find %s on PATH" % file_name) -------------------------------------------------------------------------------- /ppg/sign/windows.py: -------------------------------------------------------------------------------- 1 | from ppg import path, SETTINGS 2 | from ppg_runtime import FbsError 3 | from os import makedirs 4 | from os.path import join, splitext, dirname, basename, exists 5 | from shutil import copy 6 | from subprocess import call, run, DEVNULL 7 | 8 | import hashlib 9 | import json 10 | import os 11 | 12 | _CERTIFICATE_PATH = 'src/sign/windows/certificate.pfx' 13 | _TO_SIGN = ('.exe', '.cab', '.dll', '.ocx', '.msi', '.xpi') 14 | 15 | def sign_windows(): 16 | if not exists(path(_CERTIFICATE_PATH)): 17 | raise FbsError( 18 | 'Could not find a code signing certificate at:\n ' 19 | + _CERTIFICATE_PATH 20 | ) 21 | if 'windows_sign_pass' not in SETTINGS: 22 | raise FbsError( 23 | "Please set 'windows_sign_pass' to the password of %s in either " 24 | "src/build/settings/secret.json, .../windows.json or .../base.json." 25 | % _CERTIFICATE_PATH 26 | ) 27 | for subdir, _, files in os.walk(path('${freeze_dir}')): 28 | for file_ in files: 29 | extension = splitext(file_)[1] 30 | if extension in _TO_SIGN: 31 | sign_file(join(subdir, file_)) 32 | 33 | def sign_file(file_path, description='', url=''): 34 | helper = _SignHelper.instance() 35 | if not helper.is_signed(file_path): 36 | helper.sign(file_path, description, url) 37 | 38 | class _SignHelper: 39 | 40 | _INSTANCE = None 41 | 42 | @classmethod 43 | def instance(cls): 44 | if cls._INSTANCE is None: 45 | cls._INSTANCE = cls(path('cache/signed')) 46 | return cls._INSTANCE 47 | 48 | def __init__(self, cache_dir): 49 | self._cache_dir = cache_dir 50 | 51 | def is_signed(self, file_path): 52 | return not call( 53 | ['signtool', 'verify', '/pa', file_path], stdout=DEVNULL, 54 | stderr=DEVNULL 55 | ) 56 | 57 | def sign(self, file_path, description, url): 58 | json_path = self._get_json_path(file_path) 59 | try: 60 | with open(json_path) as f: 61 | cached = json.load(f) 62 | is_in_cache = description == cached['description'] and \ 63 | url == cached['url'] and \ 64 | self._hash(file_path) == cached['hash'] 65 | except FileNotFoundError: 66 | is_in_cache = False 67 | if not is_in_cache: 68 | self._sign(file_path, description, url) 69 | copy(self._get_path_in_cache(file_path), file_path) 70 | 71 | def _sign(self, file_path, description, url): 72 | path_in_cache = self._get_path_in_cache(file_path) 73 | makedirs(dirname(path_in_cache), exist_ok=True) 74 | copy(file_path, path_in_cache) 75 | hash_ = self._hash(path_in_cache) 76 | self._run_signtool(path_in_cache, 'sha1') 77 | self._run_signtool(path_in_cache, 'sha256') 78 | with open(self._get_json_path(file_path), 'w') as f: 79 | json.dump({ 80 | 'description': description, 81 | 'url': url, 82 | 'hash': hash_ 83 | }, f) 84 | 85 | def _get_json_path(self, file_path): 86 | return self._get_path_in_cache(file_path) + '.json' 87 | 88 | def _get_path_in_cache(self, file_path): 89 | return join(self._cache_dir, basename(file_path)) 90 | 91 | def _run_signtool(self, file_path, digest_alg, description='', url=''): 92 | password = SETTINGS['windows_sign_pass'] 93 | args = [ 94 | 'signtool', 'sign', '/f', path(_CERTIFICATE_PATH), '/p', password 95 | ] 96 | if 'windows_sign_server' in SETTINGS: 97 | args.extend(['/tr', SETTINGS['windows_sign_server']]) 98 | if description: 99 | args.extend(['/d', description]) 100 | if url: 101 | args.extend(['/du', url]) 102 | args.extend(['/as', '/fd', digest_alg, '/td', digest_alg]) 103 | args.append(file_path) 104 | run(args, check=True, stdout=DEVNULL) 105 | 106 | def _hash(self, file_path): 107 | bufsize = 65536 108 | hasher = hashlib.md5() 109 | with open(file_path, 'rb') as f: 110 | buf = f.read(bufsize) 111 | while buf: 112 | hasher.update(buf) 113 | buf = f.read(bufsize) 114 | return hasher.hexdigest() -------------------------------------------------------------------------------- /examples/hybryd-app/src/main/python/main.py: -------------------------------------------------------------------------------- 1 | import sys 2 | from ppg_runtime.application_context.PySide6 import ApplicationContext 3 | from ppg_runtime.application_context import PPGLifeCycle, Pydux, init_lifecycle, BridgeManager 4 | from ppg_runtime.application_context.devtools.reloader import hot_reloading 5 | from ppg_runtime.application_context.utils import app_is_frozen 6 | from PySide6.QtWidgets import QMainWindow, QPushButton 7 | from PySide6.QtCore import QUrl 8 | from PySide6.QtWebEngineWidgets import QWebEngineView 9 | from PySide6.QtWebEngineCore import QWebEnginePage 10 | 11 | # -------------------------------------------------------------------------------------- 12 | # Important! Production Considerations for Hot Reloading 13 | # -------------------------------------------------------------------------------------- 14 | # Hot reloading is a development tool that allows you to instantly see UI changes 15 | # when you save a file. It's extremely useful for rapid prototyping and designing 16 | # interfaces. 17 | # 18 | # However, this functionality is not designed for use in production environments. 19 | # For the final version of your application, it is highly recommended to remove 20 | # the code related to hot reloading, such as the `@hot_reloading` decorator 21 | # and the `window._init_hot_reload_system(__file__)` call. 22 | # 23 | # Keeping hot reloading active in production can negatively impact the application's 24 | # performance, stability, and security. 25 | # -------------------------------------------------------------------------------------- 26 | 27 | @init_lifecycle 28 | @hot_reloading 29 | class Pwa(QMainWindow, PPGLifeCycle, Pydux): 30 | def component_will_mount(self): 31 | self.subscribe_to_store(self) 32 | 33 | def render_(self): 34 | 35 | # loads the embedded browser engine (WebEngineView) where the PWA will be displayed (index.html) 36 | self.engine = QWebEngineView(self) 37 | self.engine.load(QUrl.fromLocalFile(self.get_resource("index.html"))) 38 | 39 | 40 | # Create a bridge for Python ↔ JavaScript communication using QWebChannel 41 | # You can create multiple bridges if needed by instantiating BridgeManager with different names 42 | self.bridge = BridgeManager(self.engine, "bridge") 43 | 44 | # Register an event called "callback" 45 | # When triggered from JS, it will call handle_callback() in Python 46 | self.bridge.register("callback", self.handle_callback) 47 | 48 | 49 | # Add buttons to demonstrate functionality (e.g., opening DevTools, emitting events to JS) 50 | self.button = QPushButton("Open DevTools", self, clicked=self.open_dev_tools) 51 | self.button2 = QPushButton("test emit", self, clicked=lambda: self.bridge.emit("callback", {"data": "Hello from Python!"})) 52 | 53 | self.setCentralWidget(self.engine) 54 | 55 | def handle_callback(self, payload): 56 | """This is a callback function that handles messages from JavaScript via the bridge. 57 | 58 | Args: 59 | payload (dict): The payload data sent from JavaScript. 60 | 61 | Returns: 62 | str: A response message indicating the result of the callback handling. 63 | """ 64 | 65 | print("Received message from JS:", payload) 66 | 67 | # You can send back a response to JavaScript if needed by returning a value 68 | return f"USER: {payload['username']} logged in successfully! (handled by Python)" 69 | 70 | def open_dev_tools(self): 71 | """Opens the DevTools window for the embedded web engine.""" 72 | 73 | self.dev_tools = QWebEngineView(self) 74 | if not self.engine.page().devToolsPage(): 75 | self.engine.page().setDevToolsPage(QWebEnginePage(self.engine.page().profile(), self.dev_tools)) 76 | self.dev_tools.setPage(self.engine.page().devToolsPage()) 77 | self.dev_tools.setWindowTitle("DevTools") 78 | self.dev_tools.show() 79 | self.dev_tools.resize(500, self.height()) 80 | self.dev_tools.move(self.width() - 500, 0) 81 | 82 | 83 | # Emit an event to JavaScript indicating that DevTools has been opened (for demonstration purposes) 84 | self.bridge.emit("devtools_opened", {"message": "DevTools opened"}) 85 | 86 | def responsive_UI(self): 87 | self.setMinimumSize(640, 480) 88 | self.button2.move(100, 0) 89 | 90 | 91 | if __name__ == '__main__': 92 | appctxt = ApplicationContext() 93 | window = Pwa() 94 | if not app_is_frozen(): 95 | window._init_hot_reload_system(__file__) 96 | window.show() 97 | exec_func = getattr(appctxt.app, 'exec', appctxt.app.exec_) 98 | sys.exit(exec_func()) -------------------------------------------------------------------------------- /ppg/resources.py: -------------------------------------------------------------------------------- 1 | from ppg import path, SETTINGS 2 | from ppg_runtime import FbsError 3 | from ppg._state import LOADED_PROFILES 4 | from glob import glob 5 | from os import makedirs 6 | from os.path import dirname, isfile, join, basename, relpath, splitext, exists 7 | from pathlib import Path 8 | from shutil import copy, copymode 9 | 10 | import re 11 | import os 12 | 13 | def copy_with_filtering( 14 | src_dir_or_file, dest_dir, replacements=None, files_to_filter=None, 15 | exclude=None, placeholder='${%s}' 16 | ): 17 | """ 18 | Copy the given file or directory to the given destination, optionally 19 | applying filtering. 20 | """ 21 | if replacements is None: 22 | replacements = SETTINGS 23 | if files_to_filter is None: 24 | files_to_filter = [] 25 | if exclude is None: 26 | exclude = [] 27 | to_copy = _get_files_to_copy(src_dir_or_file, dest_dir, exclude) 28 | to_filter = _paths(files_to_filter) 29 | for src, dest in to_copy: 30 | makedirs(dirname(dest), exist_ok=True) 31 | if files_to_filter is None or src in to_filter: 32 | _copy_with_filtering(src, dest, replacements, placeholder) 33 | else: 34 | copy(src, dest) 35 | 36 | def get_icons(): 37 | """ 38 | Return a list [(size, scale, path)] of available app icons for the current 39 | platform. 40 | """ 41 | result = {} 42 | for profile in LOADED_PROFILES: 43 | icons_dir = 'src/main/icons/' + profile 44 | for icon_path in glob(path(icons_dir + '/*.png')): 45 | name = splitext(basename(icon_path))[0] 46 | match = re.match('(\d+)(?:@(\d+)x)?', name) 47 | if not match: 48 | raise FbsError('Invalid icon name: ' + icon_path) 49 | size, scale = int(match.group(1)), int(match.group(2) or '1') 50 | result[(size, scale)] = icon_path 51 | return [(size, scale, path) for (size, scale), path in result.items()] 52 | 53 | def _get_files_to_copy(src_dir_or_file, dest_dir, exclude): 54 | excludes = _paths(map(path, exclude)) 55 | if isfile(src_dir_or_file) and src_dir_or_file not in excludes: 56 | yield src_dir_or_file, join(dest_dir, basename(src_dir_or_file)) 57 | else: 58 | for (subdir, _, files) in os.walk(src_dir_or_file): 59 | dest_subdir = join(dest_dir, relpath(subdir, src_dir_or_file)) 60 | for file_ in files: 61 | file_path = join(subdir, file_) 62 | dest_path = join(dest_subdir, file_) 63 | if file_path not in excludes: 64 | yield file_path, dest_path 65 | 66 | def _copy_with_filtering( 67 | src_file, dest_file, dict_, placeholder='${%s}', encoding='utf-8' 68 | ): 69 | replacements = [] 70 | for key, value in dict_.items(): 71 | old = (placeholder % key).encode(encoding) 72 | new = str(value).encode(encoding) 73 | replacements.append((old, new)) 74 | with open(src_file, 'rb') as open_src_file: 75 | with open(dest_file, 'wb') as open_dest_file: 76 | for line in open_src_file: 77 | new_line = line 78 | for old, new in replacements: 79 | new_line = new_line.replace(old, new) 80 | open_dest_file.write(new_line) 81 | copymode(src_file, dest_file) 82 | 83 | class _paths: 84 | def __init__(self, paths): 85 | self._paths = [] 86 | # _defaults includes "files_to_filter" - eg. Installer.nsi. If these 87 | # files don't also exist in the "user's" src/ directory, then 88 | # Path(p).resolve() raises FileNotFoundError. Handle this: 89 | for p in paths: 90 | try: 91 | self._paths.append(self._resolve_strict(Path(p))) 92 | except FileNotFoundError: 93 | pass 94 | def __contains__(self, item): 95 | item = Path(item).resolve() 96 | for p in self._paths: 97 | # We do `p == item` here instead of `p.samefile(item)` because a 98 | # user reported that the former does not work. The affected paths 99 | # were in a VirtualBox shared folder in a Windows guest. They had 100 | # different st_ino values even though the paths were the same. 101 | # See https://github.com/mherrmann/fbs/issues/112. 102 | if p == item or p in item.parents: 103 | return True 104 | return False 105 | def _resolve_strict(self, path_): 106 | try: 107 | return path_.resolve(strict=True) 108 | except TypeError: 109 | # Python < 3.6: 110 | return path_.resolve() 111 | 112 | def _copy(path_fn, src, dst): # Used by several other internal ppg modules 113 | src = path_fn(src) 114 | if exists(src): 115 | filter_ = [path_fn(f) for f in SETTINGS['files_to_filter']] 116 | copy_with_filtering(src, dst, files_to_filter=filter_) 117 | return True 118 | return False --------------------------------------------------------------------------------