Le caratteristiche di sysconfig sono state estratte da distutils per creare un modulo a se stante. Esso include funzioni per determinare le impostazioni usate per compilare e installare l'interprete corrente.

Variabili di Configurazione

L'accesso alle impostazioni di configurazione in fase di compilazione sono fornite tramite due funzioni, get_config_vars() ritorna un dizionario che mappa i nomi delle variabili di configurazione ai valori.

# sysconfig_get_config_vars.py

import sysconfig

config_values = sysconfig.get_config_vars()
print('Trovate {} impostazioni di configurazione'.format(
    len(config_values.keys())))

print('\nAlcune salienti:\n')

print(' Prefissi di installazione:')
print('  prefix={prefix}'.format(**config_values))
print('  exec_prefix={exec_prefix}'.format(**config_values))

print('\n Info di versione:')
print('  py_version={py_version}'.format(**config_values))
print('  py_version_short={py_version_short}'.format(
    **config_values))
print('  py_version_nodot={py_version_nodot}'.format(
    **config_values))

print('\n Directory base:')
print('  base={base}'.format(**config_values))
print('  platbase={platbase}'.format(**config_values))
print('  userbase={userbase}'.format(**config_values))
print('  srcdir={srcdir}'.format(**config_values))

print('\n Flag di Compilatore e linker:')
print('  LDFLAGS={LDFLAGS}'.format(**config_values))
print('  BASECFLAGS={BASECFLAGS}'.format(**config_values))
print('  Py_ENABLE_SHARED={Py_ENABLE_SHARED}'.format(
    **config_values))

Il livello di dettaglio disponibile attraverso le API di sysconfig dipendono dalla piattaforma nella quale il programma è in esecuzione. Su sistemi POSIX tipo Linux od OS X, il file Makefile usato per compilare l'interprete e il file header config.h generato per la compilazione sono esaminati e vengono rese disponibili tutte le variabili trovate all'interno. Su sistemi non POSIX tipo Windows, le impostazioni sono limitate a pochi percorsi, estensioni di nomi di file e dettagli di versione.

$ python3 sysconfig_get_config_vars.py

Trovate 695 impostazioni di configurazione

Alcune salienti:

 Prefissi di installazione:
  prefix=/usr
  exec_prefix=/usr

 Info di versione:
  py_version=3.8.5
  py_version_short=3.8
  py_version_nodot=38

 Directory base:
  base=/dati/dev/python/pymotw3restyling/.venv
  platbase=/dati/dev/python/pymotw3restyling/.venv
  userbase=/home/robby/.local
  srcdir=/usr/lib/python3.8/config-3.8-x86_64-linux-gnu

 Flag di Compilatore e linker:
  LDFLAGS=-Wl,-Bsymbolic-functions  -Wl,-z,relro -g -fwrapv -O2   
  BASECFLAGS=-Wno-unused-result -Wsign-compare
  Py_ENABLE_SHARED=1

Passando nomi di variabili a get_config_vars() si modifica il valore di ritorno in una lista creata aggiungendo tutti i valori per quelle variabili.

# sysconfig_get_config_vars_by_name.py

import sysconfig

bases = sysconfig.get_config_vars('base', 'platbase', 'userbase')
print('Directory base:')
for b in bases:
    print('  ', b)

Questo esempio costruisce una lista di tutte le directory base di installazione dove si possono trovare i moduli nel sistema corrente.

$ python3 sysconfig_get_config_vars_by_name.py

Directory base:
   /dati/dev/python/pymotw3restyling/.venv
   /dati/dev/python/pymotw3restyling/.venv
   /home/robby/.local

Quando è necessario un solo valore di configurazione, si usi get_config_var() per ottenerlo.

# sysconfig_get_config_var.py

import sysconfig

print('Directory base utente:',
      sysconfig.get_config_var('userbase'))
print('Variable sconosciuta :',
      sysconfig.get_config_var('NoSuchVariable'))

Se la variabile non viene trovata, get_config_var() ritorna None invece che sollevare una eccezione.

$ python3 sysconfig_get_config_var.py

Directory base utente: /home/robby/.local
Variable sconosciuta : None

Percorsi di Installazione

sysconfig è principalmente concepito per essere usato dagli strumenti di installaizone e assemblaggio. Come risultato, mentre fornisce accesso a impostazioni di configurazione generali tipo la versione dell'interprete, è focalizzato sulle informazioni necessarie per trovare parti della distribuzione di Python attualmente installate su di un sistema. Le locazioni usate per installare un pacchetto dipendono dallo schema usato.

Uno schema (scheme) è un insieme di directory predefinite specifiche alla piattaforma organizzate in base agli standard e le linee guida della piattaforma per l'assemblaggio. Ci sono diversi schemi per installare in una locazione a livello di sito oppure una directory privata che appartiene all'utente. L'intero insieme di schemi può essere ottenuto con get_scheme_names().

# sysconfig_get_scheme_names.py

import sysconfig

for name in sysconfig.get_scheme_names():
    print(name)

Non esiste il concetto di "schema corrente" per se. Lo schema predefinito dipende dalla piattaforma, e lo schema effettivamente utilizzato dipende da opzioni fornite al programma di installazione. Se il sistema corrente sta eseguendo un sistema operativo conforme POSIX, l'impostazione predefinita è posix_prefix. Altrimenti l'impostazione predefinita è il nome del sistema operativo, definita in os.name.

$ python3 sysconfig_get_scheme_names.py

nt
nt_user
osx_framework_user
posix_home
posix_prefix
posix_user

Ogni schema definisce un insieme di percorsi usati per i pacchetti di installazione. Per un elenco dei nomi di percorso, si usi get_path_names().

# sysconfig_get_path_names.py

import sysconfig

for name in sysconfig.get_path_names():
    print(name)

Alcuni dei percorsi potrebbero essere gli stessi per un dato schema, ma gli installatori non dovrebbe fare alcuna assunzione circa la locazione effettiva dei percorsi. Ciascun nome ha un particolare significato semantico, quindi dovrebbe essere usato il nome corretto per trovare il percorso per un dato file durante una installazione. Si faccia riferimento alla tabella di seguito per un elenco completo dei nomi di percorso e del loro significato.

$ python3 sysconfig_get_path_names.py

stdlib
platstdlib
purelib
platlib
include
scripts
data

Si usi get_paths() per ottenere le effettive directory associate a uno schema.

# sysconfig_get_paths.py

import sysconfig
import os

for scheme in ['posix_prefix', 'posix_user']:
    print(scheme)
    print('=' * len(scheme))
    paths = sysconfig.get_paths(scheme=scheme)
    prefix = os.path.commonprefix(list(paths.values()))
    print('prefix = {}\n'.format(prefix))
    for name, path in sorted(paths.items()):
        print('{}\n  .{}'.format(name, path[len(prefix):]))
    print()

Questo esempio mostra la differenza tra percorsi a livello di sistema usati per posix_prefix sotto una infrastruttura costruita su un sistema Linux, e i valori specifici utente per posix_user.

$ python3 sysconfig_get_paths.py

posix_prefix
============
prefix = /

data
  .dati/dev/python/pymotw3restyling/.venv
include
  .usr/include/python3.8
platinclude
  .usr/include/python3.8
platlib
  .dati/dev/python/pymotw3restyling/.venv/lib/python3.8/site-packages
platstdlib
  .dati/dev/python/pymotw3restyling/.venv/lib/python3.8
purelib
  .dati/dev/python/pymotw3restyling/.venv/lib/python3.8/site-packages
scripts
  .dati/dev/python/pymotw3restyling/.venv/bin
stdlib
  .usr/lib/python3.8

posix_user
==========
prefix = /home/robby/.local

data
  .
include
  ./include/python3.8
platlib
  ./lib/python3.8/site-packages
platstdlib
  ./lib/python3.8
purelib
  ./lib/python3.8/site-packages
scripts
  ./bin
stdlib
  ./lib/python3.8

Per un percorso individuale si chiami get_path().

# sysconfig_get_path.py

import sysconfig
import pprint

for scheme in ['posix_prefix', 'posix_user']:
    print(scheme)
    print('=' * len(scheme))
    print('purelib =', sysconfig.get_path(name='purelib',
                                          scheme=scheme))
    print()

Usando get_path() equivale a salvare il valore di get_paths() e cercare la chiave nel dizionario. Se sono necessari diversi percorsi, get_paths() è più efficiente in quanto non ricalcola tutti i percorsi ogni volta.

$ python3 sysconfig_get_path.py

posix_prefix
============
purelib = /dati/dev/python/pymotw3restyling/.venv/lib/python3.8/site-packages

posix_user
==========
purelib = /home/robby/.local/lib/python3.8/site-packages

Versioni di Python e Piattaforma

Sebbene sys includa qualche identificazione basica riguardo alla piattaforma, non è sufficientemente dettagliata affinchè possa essere usata per installare pacchetti binari visto che sys.platform non sempre include informazioni sull'architettura hardware, dimensioni di istruzione o altri valori che condizionano la compatibilità dei binari delle librerie. Per una specifica più precisa della piattaforma, si usi get_platform().

# sysconfig_get_platform.py

import sysconfig

print(sysconfig.get_platform())

$ python3 sysconfig_get_platform.py

linux-x86_64

Per praticità, la versione dell'interprete via sys.version_info è anche disponibile via get_python_version() in sysconfig.

# sysconfig_get_python_version.py

import sysconfig
import sys

print('sysconfig.get_python_version():',
      sysconfig.get_python_version())
print('\nsys.version_info:')
print('  maggiore        :', sys.version_info.major)
print('  minore          :', sys.version_info.minor)
print('  micro           :', sys.version_info.micro)
print('  livello rilascio:', sys.version_info.releaselevel)
print('  seriale         :', sys.version_info.serial)

get_python_version() ritorna una stringa adatta all'uso nella costruzione di percorsi specifici a livello di versione.

$ python3 sysconfig_get_python_version.py

sysconfig.get_python_version(): 3.8

sys.version_info:
  maggiore        : 3
  minore          : 8
  micro           : 5
  livello rilascio: final
  seriale         : 0