Come posso avere più di una possibilità nella riga shebang di uno script?

Sono in una situazione un po 'interessante in cui ho uno script Python che può teoricamente essere gestito da una varietà di utenti con una varietà di ambienti (e PATH) e su una varietà di sistemi Linux. Voglio che questo script sia eseguibile sul maggior numero possibile di questi senza restrizioni artificiali. Ecco alcune impostazioni note:

• Python 2.6 è la versione di Python del sistema, quindi python, python2 e python2.6 esistono tutti in / usr / bin (e sono equivalenti).
• Python 2.6 è la versione del sistema Python, come sopra, ma Python 2.7 è installato accanto ad esso come python2.7.
• Python 2.4 è la versione del sistema Python, che il mio script non supporta. In / usr / bin abbiamo python, python2 e python2.4 che sono equivalenti e python2.5, che supporta lo script.

Voglio eseguire lo stesso script python eseguibile su tutti e tre questi. Sarebbe bello se tentasse di usare prima /usr/bin/python2.7, se esiste, quindi ripiegare su /usr/bin/python2.6, quindi ripiegare su /usr/bin/python2.5, quindi semplicemente errore se nessuno di quelli era presente. Tuttavia, non sono troppo preso dall'uso della versione 2.x più recente possibile, purché sia ​​in grado di trovare uno degli interpreti corretti, se presente.

La mia prima inclinazione era quella di cambiare la linea di shebang da:

#!/usr/bin/python

per

#!/usr/bin/python2.[5-7]

dal momento che funziona bene in bash. Ma eseguire lo script dà:

/usr/bin/python2.[5-7]: bad interpreter: No such file or directory

Va bene, quindi provo quanto segue, che funziona anche in bash:

#!/bin/bash -c /usr/bin/python2.[5-7]

Ma ancora una volta, questo non riesce con:

/bin/bash: - : invalid option

Ok, ovviamente potrei semplicemente scrivere uno script shell separato che trova l'interprete corretto ed esegue lo script Python usando qualunque interprete trovato. Troverei una seccatura distribuire due file dove uno dovrebbe bastare purché sia ​​eseguito con l'interprete Python 2 più aggiornato installato. Chiedere alle persone di invocare esplicitamente l'interprete (ad es. $ python2.5 script.py) Non è un'opzione. Fare affidamento sul PERCORSO dell'utente impostato in un determinato modo non è un'opzione.

Modificare:

Il controllo della versione all'interno dello script Python non funzionerà poiché sto usando l'istruzione "with" che esiste a partire da Python 2.6 (e può essere utilizzata in 2.5 con from __future__ import with_statement). Questo fa sì che lo script fallisca immediatamente con un SyntaxError ostile all'utente e mi impedisce di avere mai l'opportunità di controllare prima la versione ed emettere un errore appropriato.

Esempio: (prova questo con un interprete Python inferiore a 2.6)

#!/usr/bin/env python

import sys

print "You'll never see this!"
sys.exit()

with open('/dev/null', 'w') as out:
    out.write('something')

Non sono esperto, ma credo che non dovresti specificare la versione esatta di Python da usare e lasciare quella scelta al sistema / utente.

Inoltre dovresti usare questo invece del percorso hardcoding a Python nello script:

#!/usr/bin/env python

o

#!/usr/bin/env python3 (or python2)

È raccomandato dal documento Python in tutte le versioni:

Una buona scelta è di solito

#!/usr/bin/env python

che cerca l'interprete Python in tutto il PERCORSO. Tuttavia, alcuni Unices potrebbero non avere il comando env, quindi potrebbe essere necessario hardcode / usr / bin / python come percorso dell'interprete.

In varie distribuzioni Python può essere installato in luoghi diversi, quindi lo envcercheràPATH . Dovrebbe essere disponibile in tutte le principali distribuzioni Linux e da quello che vedo in FreeBSD.

Lo script dovrebbe essere eseguito con quella versione di Python che si trova nel PERCORSO e che è stata scelta dalla tua distribuzione *.

Se il tuo script è compatibile con tutte le versioni di Python tranne la 2.4, dovresti semplicemente controllare al suo interno se è eseguito in Python 2.4 e stampare alcune informazioni ed uscire.

Altro da leggere

• Qui puoi trovare esempi in quali luoghi Python potrebbe essere installato in diversi sistemi.
• Qui puoi trovare alcuni vantaggi e svantaggi per l'uso env.
• Qui puoi trovare esempi di manipolazione PATH e risultati diversi.

Nota

* In Gentoo c'è uno strumento chiamato eselect. Usandolo puoi impostare le versioni predefinite di diverse applicazioni (incluso Python) come predefinito:

$ eselect python list
Available Python interpreters:
  [1]   python2.6
  [2]   python2.7 *
  [3]   python3.2
$ sudo eselect python set 1
$ eselect python list
Available Python interpreters:
  [1]   python2.6 *
  [2]   python2.7
  [3]   python3.2

Sulla base di alcune idee tratte da alcuni commenti, sono riuscito a mettere insieme un brutto hack che sembra funzionare. Lo script diventa uno script bash che avvolge uno script Python e lo passa a un interprete Python tramite un "documento qui".

All'inizio:

#!/bin/bash

''':'
vers=( /usr/bin/python2.[5-7] )
latest="${vers[$((${#vers[@]} - 1))]}"
if !(ls $latest &>/dev/null); then
    echo "ERROR: Python versions < 2.5 not supported"
    exit 1
fi
cat <<'# EOF' | exec $latest - "$@"
''' #'''

Il codice Python va qui. Quindi alla fine:

# EOF

Quando l'utente esegue lo script, la versione più recente di Python tra 2.5 e 2.7 viene utilizzata per interpretare il resto dello script come un documento qui.

Una spiegazione su alcuni shenanigans:

Le cose a tre virgolette che ho aggiunto consentono anche di importare lo stesso script come modulo Python (che utilizzo a scopo di test). Quando viene importato da Python, tutto tra la prima e la seconda virgoletta singola tripla viene interpretato come una stringa a livello di modulo e la terza virgoletta tripla singola viene commentata. Il resto è Python ordinario.

Quando eseguito direttamente (come uno script bash ora), le prime due virgolette singole diventano una stringa vuota e la terza virgoletta singola costituisce un'altra stringa con la quarta virgoletta singola, contenente solo due punti. Questa stringa è interpretata da Bash come no-op. Tutto il resto è sintassi di Bash per alterare i binari di Python in / usr / bin, selezionare l'ultimo ed eseguire exec, passando il resto del file come documento qui. Il documento qui inizia con una tripla virgoletta Python contenente solo un segno hash / pound / octothorpe. Il resto dello script viene quindi interpretato come normale fino a quando la riga "# EOF" termina il documento qui.

Sento che questo è perverso, quindi spero che qualcuno abbia una soluzione migliore.

La linea shebang può specificare solo un percorso fisso per un interprete. C'è il #!/usr/bin/envtrucco per cercare l'interprete nel PATHma questo è tutto. Se vuoi maggiore raffinatezza, dovrai scrivere del codice shell wrapper.

La soluzione più ovvia è scrivere uno script wrapper. Chiama lo script python foo.reale crea uno script wrapper foo:

#!/bin/sh
if type python2 >/dev/null 2>/dev/null; then
  exec python2 "$0.real" "$@"
else
  exec python "$0.real" "$@"
fi

Se vuoi mettere tutto in un file, spesso puoi trasformarlo in un poliglotta che inizia con una #!/bin/shlinea (quindi verrà eseguita dalla shell) ma è anche uno script valido in un'altra lingua. A seconda della lingua, un poliglotta può essere impossibile (se #!, ad esempio, causa un errore di sintassi). In Python, non è molto difficile.

#!/bin/sh
''':'
if type python2 >/dev/null 2>/dev/null; then
  exec python2 "$0.real" "$@"
else
  exec python "$0.real" "$@"
fi
'''
# real Python script starts here
def …

(L'intero testo tra '''e '''è una stringa Python al livello superiore, che non ha alcun effetto. Per la shell, la seconda riga è ''':'che dopo aver rimosso le virgolette è il comando no-op :.)

Poiché i tuoi requisiti indicano un elenco noto di file binari, puoi farlo in Python con il seguente. Non funzionerebbe oltre una versione minore / maggiore a una cifra di Python, ma non vedo che ciò accadrà presto.

Esegue la versione più alta che si trova sul disco dall'elenco ordinato e crescente di pitoni con versione, se la versione taggata sul binario è superiore alla versione corrente dell'esecuzione di Python. L '"elenco crescente ordinato di versioni" è il bit importante per questo codice.

#!/usr/bin/env python
import os, sys

pythons = [ '/usr/bin/python2.3','/usr/bin/python2.4', '/usr/bin/python2.5', '/usr/bin/python2.6', '/usr/bin/python2.7' ]
py = list(filter( os.path.isfile, pythons ))
if py:
  py = py.pop()
  thepy = int( py[-3:-2] + py[-1:] )
  mypy  = int( ''.join( map(str, sys.version_info[0:2]) ) )
  if thepy > mypy:
    print("moving versions to "+py)
    args = sys.argv
    args.insert( 0, sys.argv[0] )
    os.execv( py, args )

print("do normal stuff")

Mi scuso per il mio pitone graffiante

È possibile scrivere un piccolo script bash che controlla l'eseguibile phython disponibile e lo chiama con lo script come parametro. Puoi quindi rendere questo script il bersaglio della linea shebang:

#!/my/python/search/script

E questo script fa semplicemente (dopo la ricerca):

"$python_path" "$1"

Non ero sicuro che il kernel avrebbe accettato questo indiretto di script ma ho controllato e funziona.

Modifica 1

Per rendere finalmente questa imbarazzante impercettibilità una buona proposta:

È possibile combinare entrambi gli script in un file. Devi solo scrivere lo script python come documento qui nello script bash (se cambi lo script python devi solo copiare nuovamente gli script insieme). O crei un file temporaneo in eg / tmp o (se python lo supporta, non lo so) fornisci lo script come input per l'interprete:

# do the search here and then
# either
cat >"tmpfile" <<"EOF" # quoting EOF is important so that bash leaves the python code alone
# here is the python script
EOF
"$python_path" "tmpfile"
# or
"$python_path" <<"EOF"
# here is the python script
EOF