Fikse PyInstaller Startup Crash i Kivy-appen ved å bruke Python 3.10

Forstå oppstartskrasj i Kivy-apper bygget med PyInstaller

Å bygge en Kivy-app ved hjelp av PyInstaller er en vanlig tilnærming for å pakke Python-applikasjoner inn i frittstående kjørbare filer. Til tross for en vellykket byggeprosess, møter utviklere noen ganger uventede krasj når de starter den pakkede appen. Dette problemet kan være spesielt frustrerende når ingen detaljert feilmelding er gitt.

I dette tilfellet kjører appen perfekt i utviklingsmiljøet, for eksempel PyCharm, men mislykkes når den pakkes med PyInstaller. Med avhengigheter som Kivy 2.3.0, Python 3.10 og biblioteker som numpy, scipy og pandaer, blir det avgjørende å identifisere kilden til krasjet for å løse problemet.

Feil som "uventet feil" uten tydelige spor peker ofte på manglende avhengigheter, feil SPEC-filkonfigurasjoner eller inkonsekvenser i virtuelt miljø. Gitt viktigheten av å sikre at alle nødvendige filer er riktig samlet, er gjennomgang av PyInstaller SPEC-filen og kjøretidsavhengigheter et avgjørende skritt.

Denne artikkelen utforsker mulige årsaker til krasj, med fokus på å forbedre SPEC-filen din, administrere skjulte importer og sikre at nødvendige Kivy-avhengigheter håndteres riktig under byggeprosessen.

Kommando	Eksempel på bruk
Analysis()	Denne kommandoen initialiserer PyInstaller-analyseprosessen, og spesifiserer hvilket Python-skript som skal samles og hvor du skal se etter avhengigheter. Det er viktig for å konfigurere hvordan appen pakkes, inkludert skjulte importer og eksterne data som binærfiler og JSON-filer.
hiddenimports	En parameter inne i Analysis() som brukes til manuelt å spesifisere Python-pakker (f.eks. numpy, pandaer, etc.) som PyInstaller kanskje ikke oppdager automatisk, og forhindrer kjøretidsfeil relatert til manglende biblioteker.
Tree()	Denne kommandoen brukes i COLLECT-trinnet for å sikre at hele kataloger, slik som sdl2.dep_bins og glew.dep_bins, er inkludert i den endelige byggingen. Den sikrer at appen inkluderer nødvendige Kivy-avhengigheter for grafikk og lyd.
COLLECT()	Samler alle kompilerte filer, binærfiler og avhengigheter i én utdatakatalog. Det sikrer at alle ressurser, biblioteker og filer er satt sammen på riktig måte for distribusjon.
datas	Brukes til å inkludere spesifikke filer (som den genererte data.json) i den medfølgende applikasjonen. Dette er kritisk når du arbeider med eksterne ressurser som JSON-filer opprettet av JsonStore i Kivy-apper.
JsonStore()	En spesifikk Kivy-kommando som brukes til å lagre og administrere data i JSON-format. Det er nødvendig å inkludere alle genererte filer eksplisitt i PyInstaller-datakonfigurasjonen for å unngå problemer med manglende filer etter pakking.
upx=True	Dette alternativet aktiverer UPX-komprimering for binærfiler under pakkeprosessen. Selv om det reduserer størrelsen på den genererte kjørbare filen, kan den noen ganger forårsake kompatibilitetsproblemer, så den aktiveres med forsiktighet.
strip=False	Deaktiverer stripping av feilsøkingssymboler fra binærfiler. Det er nyttig for å diagnostisere oppstartsproblemer og sporingsfeil under kjøring, spesielt når appen krasjer med minimal feilutgang.
bootloader_ignore_signals	Et flagg som sikrer at PyInstallers bootloader vil ignorere operativsystemsignaler som SIGTERM. Dette kan forhindre for tidlig avslutning av appen under oppstart, noe som kan være en årsak til uventede krasj.

Feilsøking av Kivy App-oppstartsfeil med PyInstaller

Skriptene ovenfor er fokusert på å løse et veldig spesifikt problem: en Kivy-app bygget med PyInstaller som krasjer ved oppstart med en "uventet feil". Det første skriptet tar for seg et potensielt problem med manglende . Dette er et vanlig problem når du bruker PyInstaller, siden det ikke automatisk oppdager alle avhengigheter, spesielt biblioteker som , , eller krypende. Ved å manuelt spesifisere disse skjulte importene i delen av SPEC-filen, sikrer vi at PyInstaller samler alle nødvendige moduler, og forhindrer at appen krasjer på grunn av manglende komponenter.

Det andre viktige trinnet i manuset er inkludering av i fase. Denne kommandoen sikrer at appens avhengigheter relatert til Kivy, slik som SDL2- og GLEW-bibliotekene, er korrekt inkludert i bygningen. Disse er avgjørende for å gjengi appens grafiske grensesnitt. Hvis disse filene ikke er inkludert, vil Kivy-appen ikke kjøre ordentlig, selv om byggeprosessen fullføres uten feil. Ved å sikre at disse binære filene er inkludert, unngår du kjøretidsproblemer knyttet til manglende grafikk eller lydkomponenter.

Skriptet adresserer også inkludering av eksterne filer, for eksempel en JSON-fil opprettet av i Kivy. Selv om denne JSON-filen genereres under kjøring, er det avgjørende å sikre at den håndteres riktig under pakkeprosessen. De argument i funksjonen lar oss eksplisitt inkludere denne filen i den medfølgende appen. Ved å gjøre det unngår vi feilen der appen krasjer på grunn av manglende eksterne datafiler under initialisering.

Til slutt ser vi også bruken av UPX-komprimering og alternativ. UPX-komprimeringen brukes til å redusere størrelsen på den medfølgende applikasjonen, noe som gjør distribusjonen enklere. Imidlertid forårsaker aktivering av UPX noen ganger kompatibilitetsproblemer, og det er derfor den er sammenkoblet med for å unngå å fjerne feilsøkingssymboler fra binærfiler. Ved å beholde feilsøkingssymbolene kan vi bedre spore årsaken til eventuelle krasj eller feil under kjøring. Deaktivering av vindusporing er en annen konfigurasjon som hjelper med å diagnostisere problemer, ettersom den lar feilmeldinger vises i konsollen, og gir innsikt i potensielle problemer ved oppstart.

# Step 1: Modify the SPEC file to include hidden imports manually
# Import necessary dependencies from Kivy, sdl2, and glew
from kivy_deps import sdl2, glew
# Add numpy, pandas, scipy to hidden imports manually
a = Analysis([r'path_to_your_app.py'],
             pathex=['.'],
             binaries=[],
             datas=[],
             hiddenimports=['numpy', 'pandas', 'scipy'],
             hookspath=[],
             runtime_hooks=[],
             excludes=[],
             noarchive=False)
# Add Tree() for all Kivy dependencies to the collect step
coll = COLLECT(exe, Tree('C:\\path_to_project'),
               a.binaries, a.zipfiles, a.datas,
               *[Tree(p) for p in (sdl2.dep_bins + glew.dep_bins)],
               strip=False, upx=True, name='Prototype')

# Step 2: Ensure that the generated JSON file from kivy.storage.jsonstore is included
from kivy.storage.jsonstore import JsonStore
# If JSONStore is used, manually add the JSON file to the build
store = JsonStore('data.json')
# Create the SPEC file to explicitly include the JSON data
datas=[('data.json', '.')],
a = Analysis([r'path_to_your_app.py'],
             pathex=['.'],
             binaries=[],
             datas=[('data.json', '.')],
             hiddenimports=[],
             hookspath=[],
             runtime_hooks=[],
             excludes=[],
             noarchive=False)
coll = COLLECT(exe, Tree('C:\\path_to_project'),
               a.binaries, a.zipfiles, a.datas,
               *[Tree(p) for p in (sdl2.dep_bins + glew.dep_bins)],
               strip=False, upx=True, name='Prototype')

Optimalisering av PyInstaller for Kivy-apper for å forhindre oppstartsfeil

Når du arbeider med PyInstaller og Kivy, er et viktig aspekt å vurdere administrasjonen av eksterne avhengigheter og biblioteker. PyInstallers standardoppførsel overser noen ganger visse biblioteker eller filer, spesielt når du arbeider med mer komplekse oppsett som virtuelle miljøer eller vitenskapelige biblioteker som f.eks. og . Sikre at all skjult import er spesifisert i parameteren er kritisk. I tillegg kan det hende at PyInstaller ikke automatisk inkluderer grafiske og multimedieavhengigheter som de fra sdl2 eller , som begge er avgjørende for Kivy-apper.

Et annet aspekt som utviklere ofte overser er relatert til virtuelle miljøer. Når du bygger en Kivy-app ved hjelp av PyInstaller i et virtuelt miljø, er det viktig å sikre at alle avhengigheter er satt sammen på riktig måte. Dette innebærer å justere innstilling for å peke på de riktige katalogene der bibliotekene er installert. Unnlatelse av å gjøre det kan føre til at den pakkede appen kjører bra i utviklingsmiljøet, men krasjer ved oppstart i produksjonen. Dette problemet kan ofte unngås ved å undersøke byggekonfigurasjonen fullstendig og sikre at alle stier og avhengigheter er riktige.

Til slutt er riktig håndtering av ressurser som bilder, fonter og datafiler avgjørende for å forhindre uventede oppstartsfeil. I Kivy-apper kreves det ofte eksterne ressurser, og hvis disse ikke er eksplisitt inkludert i PyInstaller seksjonen, kan appen krasje under initialisering når du prøver å få tilgang til manglende filer. Det er viktig å verifisere at alle filene som trengs av appen under kjøring er riktig inkludert i den endelige byggingen.

1. Hvorfor krasjer Kivy-appen min etter å ha bygget med PyInstaller?
2. Den vanligste årsaken er manglende avhengigheter. Sørg for alle nødvendige biblioteker, som f.eks , , og , er inkludert som skjulte importer i PyInstaller SPEC-filen.
3. Hvordan inkluderer jeg sdl2- og glew-avhengighetene i bygget mitt?
4. Bruk funksjon i trinn for å inkludere sdl2 og glew binære filer. Disse er nødvendige for Kivys grafiske operasjoner.
5. Kan PyInstaller håndtere virtuelle miljøer riktig?
6. Ja, men du må stille inn riktig i SPEC-filen for å peke til miljøet der avhengighetene er installert, ellers kan det hende at appen ikke finner dem.
7. Hva skal jeg gjøre hvis appen min fungerer i PyCharm, men krasjer når den pakkes?
8. Sørg for at alle kjøretidsavhengigheter er inkludert, og kontroller at delen i SPEC-filen inneholder alle nødvendige filer som brukes av appen din, som fonter, bilder eller JSON-data.
9. Hvordan kan jeg feilsøke meldingen "uventet feil" uten sporing?
10. Still inn parameter til i skritt. Dette vil sende ut feil til terminalen, slik at du kan spore opp årsaken til krasjet.