Menginstal Modul Python (Versi Legacy)
**************************************

Penulis:
   Greg Ward

Lihat juga:

  Memasang Modul-modul Python
     The up to date module installation documentations

This document describes the Python Distribution Utilities
("Distutils") from the end-user's point-of-view, describing how to
extend the capabilities of a standard Python installation by building
and installing third-party Python modules and extensions.

Catatan:

  Panduan ini hanya mencakup alat dasar untuk membangun dan
  mendistribusikan ekstensi yang disediakan sebagai bagian dari versi
  Python ini. Alat pihak ketiga menawarkan alternatif yang lebih mudah
  digunakan dan lebih aman. Lihat bagian rekomendasi cepat dalam
  Panduan Pengguna Pengemasan Python untuk informasi lebih lanjut.


Pengenalan
==========

Although Python's extensive standard library covers many programming
needs, there often comes a time when you need to add some new
functionality to your Python installation in the form of third-party
modules.  This might be necessary to support your own programming, or
to support an application that you want to use and that happens to be
written in Python.

In the past, there has been little support for adding third-party
modules to an existing Python installation.  With the introduction of
the Python Distribution Utilities (Distutils for short) in Python 2.0,
this changed.

This document is aimed primarily at the people who need to install
third-party Python modules: end-users and system administrators who
just need to get some Python application running, and existing Python
programmers who want to add some new goodies to their toolbox.  You
don't need to know Python to read this document; there will be some
brief forays into using Python's interactive mode to explore your
installation, but that's it.  If you're looking for information on how
to distribute your own Python modules so that others may use them, see
the Mendistribusikan Modul Python (versi peninggalan) manual.
Debugging the setup script may also be of interest.


Best case: trivial installation
-------------------------------

In the best case, someone will have prepared a special version of the
module distribution you want to install that is targeted specifically
at your platform and is installed just like any other software on your
platform.  For example, the module developer might make an executable
installer available for Windows users, an RPM package for users of
RPM-based Linux systems (Red Hat, SuSE, Mandrake, and many others), a
Debian package for users of Debian-based Linux systems, and so forth.

In that case, you would download the installer appropriate to your
platform and do the obvious thing with it: run it if it's an
executable installer, "rpm --install" it if it's an RPM, etc.  You
don't need to run Python or a setup script, you don't need to compile
anything---you might not even need to read any instructions (although
it's always a good idea to do so anyway).

Of course, things will not always be that easy.  You might be
interested in a module distribution that doesn't have an easy-to-use
installer for your platform.  In that case, you'll have to start with
the source distribution released by the module's author/maintainer.
Installing from a source distribution is not too hard, as long as the
modules are packaged in the standard way.  The bulk of this document
is about building and installing modules from standard source
distributions.


The new standard: Distutils
---------------------------

Jika Anda mengunduh distribusi sumber modul, Anda dapat mengetahui
dengan cepat apakah itu dikemas dan didistribusikan dengan cara
standar, yaitu menggunakan Distutils. Pertama, nama distribusi dan
nomor versi akan ditampilkan secara mencolok di nama arsip yang
diunduh, mis. "foo-1.0.tar.gz" atau "widget-0.9.7.zip". Selanjutnya,
arsip akan mengekstrak file ke dalam direktori dengan nama yang mirip:
"foo-1.0" atau "widget-0.9.7". Selain itu, distribusi akan berisi
skrip pengaturan "setup.py", dan file bernama "README.txt" atau
mungkin hanya "README", yang seharusnya menjelaskan bahwa membangun
dan menginstal distribusi modul adalah masalah sesederhana menjalankan
satu perintah dari terminal:

   python setup.py install

Untuk Windows, perintah ini harus dijalankan dari jendela prompt
perintah (Start ‣ Accessories):

   setup.py install

Jika semua ini benar, maka Anda telah mengetahui cara membuat dan
menginstal modul yang baru saja Anda unduh: Jalankan perintah di atas.
Kecuali Anda perlu menginstal sesuatu dengan cara non-standar atau
menyesuaikan proses build, Anda tidak benar-benar membutuhkan manual
ini. Atau lebih tepatnya, perintah di atas adalah semua yang Anda
butuhkan untuk keluar dari manual ini.


Bangun dan Install Standar
==========================

Seperti yang dijelaskan di bagian The new standard: Distutils,
membangun dan menginstal distribusi modul menggunakan Distutils
biasanya merupakan satu perintah sederhana untuk dijalankan dari
terminal:

   python setup.py install


Variasi platform
----------------

Anda harus selalu menjalankan perintah penyiapan dari direktori root
distribusi, yaitu subdirektori tingkat atas yang diuraikan oleh
distribusi sumber modul. Misalnya, jika Anda baru saja mengunduh
distribusi sumber modul "foo-1.0.tar.gz" ke sistem Unix, hal yang
normal untuk dilakukan adalah:

   gunzip -c foo-1.0.tar.gz | tar xf -    # unpacks into directory foo-1.0
   cd foo-1.0
   python setup.py install

Di Windows, Anda mungkin mengunduh "foo-1.0.zip". Jika Anda mengunduh
file arsip ke "C:\Temp", maka file akan diurai menjadi
"C:\Temp\foo-1.0"; Anda dapat menggunakan manipulator arsip dengan
antarmuka pengguna grafis (seperti WinZip) atau alat baris perintah
(seperti **unzip** atau **pkunzip**) untuk mengekstrak arsip.
Kemudian, buka jendela prompt perintah dan jalankan:

   cd c:\Temp\foo-1.0
   python setup.py install


Membagi pekerjaan
-----------------

Menjalankan "setup.py install" akan membangun dan menginstal semua
modul dalam satu proses. Jika Anda lebih suka bekerja secara bertahap
---terutama berguna jika Anda ingin menyesuaikan proses build, atau
jika ada yang sesuatu salah---Anda dapat menggunakan skrip penyiapan
untuk melakukan satu hal dalam satu waktu. Ini sangat membantu ketika
build dan install akan dilakukan oleh pengguna yang berbeda---
misalnya, Anda mungkin ingin membangun distribusi modul dan
menyerahkannya ke administrator sistem untuk instalasi (atau lakukan
sendiri, dengan hak istimewa super-user ).

Misalnya, Anda bisa membangun semuanya dalam satu langkah, lalu
menginstal semuanya di langkah kedua, dengan menjalankan skrip
pengaturan dua kali:

   python setup.py build
   python setup.py install

Jika Anda melakukan ini, Anda akan melihat bahwa menjalankan perintah
**install** pertama-tama akan menjalankan perintah **build**, yang---
dalam hal ini---dapat dengan cepat memberi tahu bahwa itu tidak ada
hubungannya, karena semua yang ada di direktori "build" adalah yang
terbaru.

Anda mungkin tidak memerlukan kemampuan ini untuk memecah banyak hal
jika yang Anda lakukan hanyalah menginstal modul yang diunduh dari
'net, tetapi ini sangat berguna untuk tugas-tugas yang lebih lanjut.
Jika Anda mulai mendistribusikan modul dan ekstensi Python Anda
sendiri, Anda akan menjalankan banyak perintah Distutils tersendiri.


Bagaimana pembangunan bekerja
-----------------------------

Seperti yang tersirat di atas, perintah **build** bertanggung jawab
untuk menempatkan file yang akan diinstal ke dalam direktori *build*.
Standarnya, ini adalah "build" di bawah root distribusi; jika Anda
terlalu mengkhawatirkan kecepatan, atau ingin menjaga struktur kode
sumber tetap murni, Anda dapat mengubah direktori build dengan opsi "
--build-base". Sebagai contoh:

   python setup.py build --build-base=/path/to/pybuild/foo-1.0

(Atau Anda dapat melakukan ini secara permanen dengan arahan di sistem
Anda atau file konfigurasi Distutils pribadi; lihat bagian File
Konfigurasi Distutils.) Biasanya, ini tidak perlu.

Tata letak default untuk build tree adalah sebagai berikut:

   --- build/ --- lib/
   or
   --- build/ --- lib.<plat>/
                  temp.<plat>/

di mana "<plat>" berkembang menjadi deskripsi singkat tentang
OS/platform perangkat keras dan versi Python saat ini. Bentuk pertama,
hanya dengan direktori "lib", digunakan untuk "distribusi modul murni"
---yaitu, distribusi modul yang hanya menyertakan modul Python murni.
Jika distribusi modul berisi ekstensi apa pun (modul yang ditulis
dalam C/C++), maka bentuk  kedua, dengan dua direktori "<plat>",
digunakan. Dalam hal ini, direktori "temp.*Plat*" menyimpan file
sementara yang dihasilkan oleh proses kompilasi/tautan yang sebenarnya
tidak terinstal. Dalam kedua kasus tersebut, direktori "lib" (atau
"lib.*Plat*") berisi semua modul Python (Python murni dan ekstensi)
yang akan diinstal.

Di masa mendatang, lebih banyak direktori akan ditambahkan untuk
menangani skrip Python, dokumentasi, biner yang dapat dieksekusi, dan
apa pun yang diperlukan untuk menangani pekerjaan penginstalan modul
dan aplikasi Python.


Bagaimana instalasi bekerja
---------------------------

Setelah perintah **build** dijalankan (apakah Anda menjalankannya
secara eksplisit, atau perintah **install** yang melakukannya untuk
Anda), cara kerja perintah **install** relatif sederhana: semua yang
harus dilakukan adalah menyalin semua yang ada di bawah "build/lib"
(atau "build/lib.*plat*") ke direktori instalasi yang Anda pilih.

Jika Anda tidak memilih direktori instalasi---yaitu, jika Anda hanya
menjalankan "setup.py install"---maka perintah  **install** akan
menginstal ke lokasi standar untuk modul Python pihak ketiga . Lokasi
ini bervariasi menurut platform dan cara Anda membuat / menginstal
Python itu sendiri. Di Unix (dan Mac OS X, yang juga berbasis Unix),
ini juga bergantung pada apakah distribusi modul yang diinstal adalah
Python murni atau berisi ekstensi ("tidak murni"):

+-------------------+-------------------------------------------------------+----------------------------------------------------+---------+
| Platform          | Lokasi installasi standar                             | Nilai bawaan                                       | Catatan |
|===================|=======================================================|====================================================|=========|
| Unix (murni)      | "*prefix*/lib/python*X.Y*/site-packages"              | "/usr/local/lib/python*X.Y*/site-packages"         | (1)     |
+-------------------+-------------------------------------------------------+----------------------------------------------------+---------+
| Unix (tidak       | "*exec-prefix*/lib/python*X.Y*/site-packages"         | "/usr/local/lib/python*X.Y*/site-packages"         | (1)     |
| murni)            |                                                       |                                                    |         |
+-------------------+-------------------------------------------------------+----------------------------------------------------+---------+
| Windows           | "*prefix*\Lib\site-packages"                          | "C:\Python*XY*\Lib\site-packages"                  | (2)     |
+-------------------+-------------------------------------------------------+----------------------------------------------------+---------+

Catatan:

1. Kebanyakan distribusi Linux menyertakan Python sebagai bagian
   standar sistem, jadi "*prefix*" dan "*exec-prefix*" biasanya
   keduanya "/usr" di Linux. Jika Anda membuat Python sendiri di Linux
   (atau sistem serupa Unix), bawaan "*prefix*" dan "*exec-prefix*"
   adalah "/usr/local".

2. Direktori instalasi default pada Windows adalah "C:\Program
   Files\Python" di bawah Python 1.6a1, 1.5.2, dan sebelumnya.

"*prefix*" dan "*exec-prefix*" adalah singkatan dari direktori tempat
Python diinstal, dan di mana ia menemukan library-nya pada saat run-
time. Mereka selalu sama di Windows, dan sangat sering sama di Unix
dan Mac OS X. Anda dapat mengetahui apa yang digunakan instalasi
Python untuk "*prefix*" dan "*exec-prefix*" dengan menjalankan Python
dalam mode interaktif dan mengetik beberapa perintah sederhana. Di
Unix, cukup ketik "python" pada prompt shell. Di bawah Windows, pilih
>>:menuelection:`Start --> Programs --> Python X.Y --> Python (command
line)`<<. Setelah penerjemah dimulai, Anda mengetik kode Python saat
diminta. Misalnya, pada sistem Linux saya, saya mengetik tiga
pernyataan Python yang ditunjukkan di bawah ini, dan mendapatkan
output seperti yang ditunjukkan, untuk mengetahui "*prefix*" dan
"*exec-prefix*" saya:

   Python 2.4 (#26, Aug  7 2004, 17:19:02)
   Type "help", "copyright", "credits" or "license" for more information.
   >>> import sys
   >>> sys.prefix
   '/usr'
   >>> sys.exec_prefix
   '/usr'

Beberapa placeholder lain digunakan dalam dokumen ini: "*X.Y*" adalah
singkatan dari versi Python, misalnya "3.2`; :file:`{abiflags}` akan
diganti dengan nilai :data:`sys.abiflags` atau string kosong untuk
platform yang tidak mendefinisikan penanda ABI; :file:`{distname}`
akan diganti dengan nama distribusi modul yang diinstal. Titik dan
kapitalisasi penting di jalur; misalnya, nilai yang menggunakan
``python3.2" di UNIX biasanya akan menggunakan "Python32" di Windows.

Jika Anda tidak ingin menginstal modul ke lokasi standar, atau jika
Anda tidak memiliki izin untuk menulis di sana, maka Anda perlu
membaca tentang instalasi alternatif di bagian Instalasi Alternatif.
Jika Anda ingin mengubah direktori instalasi Anda lebih berat, lihat
bagian Instalasi kustom pada instalasi kustom.


Instalasi Alternatif
====================

Seringkali, kita perlu atau ingin menginstal modul ke lokasi selain
lokasi standar untuk modul Python pihak ketiga. Misalnya, pada sistem
Unix Anda mungkin tidak memiliki izin untuk menulis ke direktori modul
standar pihak ketiga. Atau Anda mungkin ingin mencoba modul sebelum
menjadikannya sebagai bagian standar dari instalasi Python lokal Anda.
Hal ini terutama berlaku saat memutakhirkan distribusi yang sudah ada:
Anda ingin memastikan basis skrip yang ada masih berfungsi dengan
versi baru sebelum benar-benar memutakhirkan.

Perintah Distutils **install** dirancang untuk membuat distribusi
modul instalasi ke lokasi alternatif sederhana dan tidak menyakitkan.
Ide dasarnya adalah Anda menyediakan direktori dasar untuk instalasi,
dan perintah **install** memilih sekumpulan direktori (disebut *skema
instalasi*) di bawah direktori dasar ini untuk menginstal file.
Detailnya berbeda di setiap platform, jadi bacalah bagian mana pun
berikut ini yang sesuai untuk Anda.

Perhatikan bahwa berbagai skema instalasi alternatif sama-sama
eksklusif: Anda dapat memberikan "--user", atau "--home", atau "--
prefix" dan "--exec-prefix", atau "--install-base" dan "--install-
platbase", tetapi Anda tidak dapat mencampur dari grup ini.


Instalasi alternatif: skema user
--------------------------------

Skema ini dirancang untuk menjadi solusi yang paling nyaman bagi
pengguna yang tidak memiliki izin menulis ke direktori paket situs
global atau tidak ingin menginstalnya. Ini diaktifkan dengan opsi
sederhana:

   python setup.py install --user

File akan dipasang ke subdirektori dari "site.USER_BASE" (selanjutnya
ditulis sebagai "*userbase*"). Skema ini menginstal modul Python murni
dan modul ekstensi di lokasi yang sama (juga dikenal sebagai
"site.USER_SITE"). Berikut adalah nilai untuk UNIX, termasuk Mac OS X:

+-----------------+-------------------------------------------------------------+
| Tipe file       | Direktori instalasi                                         |
|=================|=============================================================|
| modul           | "*userbase*/lib/python*X.Y*/site-packages"                  |
+-----------------+-------------------------------------------------------------+
| skrip           | "*userbase*/bin"                                            |
+-----------------+-------------------------------------------------------------+
| data            | "*userbase*"                                                |
+-----------------+-------------------------------------------------------------+
| C header        | "*userbase*/include/python*X.Y**abiflags*/*distname*"       |
+-----------------+-------------------------------------------------------------+

Dan inilah nilai yang digunakan di Windows:

+-----------------+-------------------------------------------------------------+
| Tipe file       | Direktori instalasi                                         |
|=================|=============================================================|
| modul           | "*userbase*\Python*XY*\site-packages"                       |
+-----------------+-------------------------------------------------------------+
| skrip           | "*userbase*\Python*XY*\Scripts"                             |
+-----------------+-------------------------------------------------------------+
| data            | "*userbase*"                                                |
+-----------------+-------------------------------------------------------------+
| C header        | "*userbase*\Python*XY*\Include{distname}"                   |
+-----------------+-------------------------------------------------------------+

Keuntungan menggunakan skema ini dibandingkan dengan skema lain yang
dijelaskan di bawah ini adalah direktori paket situs pengguna dalam
kondisi normal selalu disertakan dalam "sys.path" (lihat "site" untuk
informasi lebih lanjut), yang mana berarti tidak ada langkah tambahan
yang harus dilakukan setelah menjalankan skrip "setup.py" untuk
menyelesaikan instalasi.

Perintah **build_ext** juga memiliki opsi "--user" untuk menambahkan
"*userbase*/include" ke path pencarian compiler untuk file header dan
"*userbase*/lib" ke path pencarian compiler untuk pustaka serta ke
path pencarian runtime untuk pustaka C bersama (rpath).


Instalasi alternatif: skema home
--------------------------------

Ide di balik "skema home" adalah Anda membangun dan memelihara
simpanan pribadi modul Python. Nama skema ini berasal dari ide
direktori "home" di Unix, karena bukan hal yang aneh bagi pengguna
Unix untuk membuat direktori home mereka memiliki layout yang mirip
dengan "/usr/" atau "/usr/local/". Skema ini dapat digunakan oleh
siapa saja, terlepas dari sistem operasi yang mereka instal.

Menginstal distribusi modul baru semudah

   python setup.py install --home=<dir>

di mana Anda dapat menyediakan direktori apa pun yang Anda suka untuk
opsi " --home". Di Unix, juru ketik yang malas cukup mengetik tilde
("~"); perintah **install** akan memperluas ini ke direktori home
Anda:

   python setup.py install --home=~

Untuk membuat Python menemukan distribusi yang diinstal dengan skema
ini, Anda mungkin harus memodifikasi path pencarian Python atau edit
"sitecustomize" (lihat "site") untuk memanggil "site.addsitedir()"
atau edit "sys.path".

Opsi "--home" menentukan direktori dasar instalasi. File diinstal ke
direktori berikut di bawah basis penginstalan sebagai berikut:

+-----------------+-------------------------------------------------------------+
| Tipe file       | Direktori instalasi                                         |
|=================|=============================================================|
| modul           | "*home*/lib/python"                                         |
+-----------------+-------------------------------------------------------------+
| skrip           | "*home*/bin"                                                |
+-----------------+-------------------------------------------------------------+
| data            | "*home*"                                                    |
+-----------------+-------------------------------------------------------------+
| C header        | "*home*/include/python/*distname*"                          |
+-----------------+-------------------------------------------------------------+

(Ganti garis miring dengan garis miring terbalik jika Anda menggunakan
Windows.)


Instalasi alternatif: Unix (skema prefiks)
------------------------------------------

"Skema prefiks" berguna ketika Anda ingin menggunakan satu instalasi
Python untuk melakukan build/install (yaitu, untuk menjalankan skrip
pengaturan), tetapi menginstal modul ke direktori modul pihak ketiga
dari instalasi Python yang berbeda (atau sesuatu yang terlihat seperti
instalasi Python yang berbeda). Jika ini terdengar agak tidak biasa,
itulah mengapa skema pengguna dan home datang sebelumnya. Namun,
setidaknya ada dua kasus yang diketahui di mana skema prefiks akan
berguna.

Pertama, pertimbangkan bahwa banyak distribusi Linux meletakkan Python
di "/usr", daripada yang lebih tradisional "/usr/local". Ini
sepenuhnya sesuai, karena dalam kasus tersebut Python adalah bagian
dari "sistem" daripada add-on lokal. Namun, jika Anda menginstal modul
Python dari sumber, Anda mungkin ingin modul tersebut masuk ke
"/usr/local/lib/python2.*X*" daripada "/usr/lib/python2.*X*". Ini
dapat dilakukan dengan:

   /usr/bin/python setup.py install --prefix=/usr/local

Kemungkinan lain adalah sistem file jaringan di mana nama yang
digunakan untuk menulis ke direktori remote berbeda dari nama yang
digunakan untuk membacanya: misalnya, interpreter Python diakses
sebagai "/usr/local/bin/python" mungkin mencari modul dalam
"/usr/local/lib/python2.*X*", tetapi modul tersebut harus dipasang ke,
misalnya, "/mnt/*@server*/export/lib/python2.*X*". Ini bisa dilakukan
dengan

   /usr/local/bin/python setup.py install --prefix=/mnt/@server/export

Dalam kedua kasus tersebut, opsi "--prefix" menentukan basis
instalasi, dan opsi "--exec-prefix" menentukan basis instalasi khusus
platform, yang digunakan untuk file khusus platform. (Saat ini, ini
hanya berarti distribusi modul non-murni, tetapi dapat diperluas ke
pustaka C, biner yang dapat dieksekusi, dll.) Jika "--exec-prefix"
tidak disediakan, defaultnya adalah "--prefix". File diinstal sebagai
berikut:

+-------------------+------------------------------------------------------------+
| Tipe file         | Direktori instalasi                                        |
|===================|============================================================|
| Modul Python      | "*prefix*/lib/python*X.Y*/site-packages"                   |
+-------------------+------------------------------------------------------------+
| modul ekstensi    | "*exec-prefix*/lib/python*X.Y*/site-packages"              |
+-------------------+------------------------------------------------------------+
| skrip             | "*prefix*/bin"                                             |
+-------------------+------------------------------------------------------------+
| data              | "*prefix*"                                                 |
+-------------------+------------------------------------------------------------+
| C header          | "*prefix*/include/python*X.Y**abiflags*/*distname*"        |
+-------------------+------------------------------------------------------------+

Tidak ada persyaratan bahwa "--prefix" atau "--exec-prefix" sebenarnya
mengarah ke instalasi Python alternatif; jika direktori yang tercantum
di atas belum ada, mereka dibuat pada saat instalasi.

Secara kebetulan, alasan sebenarnya mengapa skema prefiks penting
adalah karena instalasi Unix standar menggunakan skema prefiks, tetapi
dengan "--prefix" dan "--exec-prefix" disediakan oleh Python sendiri
sebagai "sys.prefix" dan "sys.exec_prefix". Jadi, Anda mungkin
berpikir Anda tidak akan pernah menggunakan skema prefiks, tetapi
setiap kali Anda menjalankan "python setup.py install" tanpa opsi
lain, Anda menggunakannya.

Perhatikan bahwa menginstal ekstensi ke instalasi Python alternatif
tidak berpengaruh pada bagaimana ekstensi tersebut dibuat: khususnya,
file header Python ("Python.h" dan teman-teman) yang diinstal dengan
interpreter Python yang digunakan untuk menjalankan skrip pengaturan
akan digunakan dalam menyusun ekstensi. Anda bertanggung jawab untuk
memastikan bahwa penafsir yang digunakan untuk menjalankan ekstensi
yang dipasang dengan cara ini kompatibel dengan interpreter yang
digunakan untuk membuatnya. Cara terbaik untuk melakukannya adalah
dengan memastikan bahwa kedua interpreter adalah versi Python yang
sama (kemungkinan build berbeda, atau mungkin salinan build yang
sama). (Tentu saja, jika "--prefix" dan "--exec-prefix"  Anda bahkan
tidak menunjuk ke instalasi Python alternatif, ini tidak penting.)


Instalasi alternatif: Windows (skema prefiks)
---------------------------------------------

Windows tidak memiliki konsep direktori home pengguna, dan karena
instalasi Python standar di bawah Windows lebih sederhana daripada di
bawah Unix, opsi "--prefix" secara tradisional digunakan untuk
menginstal paket tambahan di lokasi terpisah pada Windows.:

   python setup.py install --prefix="\Temp\Python"

untuk menginstal modul ke direktori "\Temp\Python" pada drive saat
ini.

Basis instalasi ditentukan oleh opsi "--prefix"; opsi "--exec-prefix"
tidak didukung pada Windows, yang berarti modul Python murni dan modul
ekstensi diinstal ke lokasi yang sama. File diinstal sebagai berikut:

+-----------------+------------------------------------------------------------+
| Tipe file       | Direktori instalasi                                        |
|=================|============================================================|
| modul           | "*prefix*\Lib\site-packages"                               |
+-----------------+------------------------------------------------------------+
| skrip           | "*prefix*\Scripts"                                         |
+-----------------+------------------------------------------------------------+
| data            | "*prefix*"                                                 |
+-----------------+------------------------------------------------------------+
| C header        | "*prefix*\Include{distname}"                               |
+-----------------+------------------------------------------------------------+


Instalasi kustom
================

Terkadang, skema instalasi alternatif yang dijelaskan di bagian
Instalasi Alternatif tidak melakukan apa yang Anda inginkan. Anda
mungkin ingin mengubah hanya satu atau dua direktori sambil menyimpan
semuanya di bawah direktori dasar yang sama, atau Anda mungkin ingin
sepenuhnya mendefinisikan ulang skema instalasi. Dalam kedua kasus
tersebut, Anda membuat *skema penginstalan kustom*.

Untuk membuat skema penginstalan kustom, Anda mulai dengan salah satu
skema alternatif dan mengganti beberapa direktori penginstalan yang
digunakan untuk berbagai jenis file, menggunakan opsi berikut:

+------------------------+-------------------------+
| Tipe file              | Opsi timpa              |
|========================|=========================|
| Modul Python           | "--install-purelib"     |
+------------------------+-------------------------+
| modul ekstensi         | "--install-platlib"     |
+------------------------+-------------------------+
| semua modul            | "--install-lib"         |
+------------------------+-------------------------+
| skrip                  | "--install-scripts"     |
+------------------------+-------------------------+
| data                   | "--install-data"        |
+------------------------+-------------------------+
| C header               | "--install-headers"     |
+------------------------+-------------------------+

Opsi timpa ini dapat bersifat relatif, absolut, atau secara eksplisit
ditentukan dalam salah satu direktori dasar instalasi. (Ada dua
direktori dasar instalasi, dan biasanya sama---mereka hanya berbeda
ketika Anda menggunakan "skema prefiks" Unix dan memberikan opsi "--
prefix" dan "--exec-prefix" yang berbeda; menggunakan "--install-lib''
akan menimpa nilai yang dihitung atau diberikan untuk ``--install-
purelib" dan "--install-platlib", dan direkomendasikan untuk skema
yang tidak membuat perbedaan antara Python dan modul ekstensi.)

Misalnya, Anda menginstal distribusi modul ke direktori home Anda di
bawah Unix---tetapi Anda ingin skrip masuk ke dalam "~/scripts"
daripada "~/bin". Seperti yang Anda duga, Anda dapat mengganti
direktori ini dengan opsi "--install-scripts"; dalam kasus ini, akan
lebih masuk akal untuk menyediakan jalur relatif, yang akan
ditafsirkan relatif terhadap direktori dasar instalasi (direktori home
Anda, dalam hal ini):

   python setup.py install --home=~ --install-scripts=scripts

Contoh Unix lainnya: misalkan instalasi Python Anda dibangun dan
diinstal dengan prefiks "/usr/local/python", jadi di bawah skrip
instalasi standar akan berakhir di "/usr/local/python/bin". Jika Anda
menginginkannya di "/usr/local/bin", Anda harus menyediakan direktori
absolut ini untuk opsi "--install-scripts":

   python setup.py install --install-scripts=/usr/local/bin

(Ini melakukan instalasi menggunakan "skema prefiks", di mana prefix
adalah apa pun yang telah diinstal interpreter Python Anda dengan---
"/usr/local/python" dalam kasus ini.)

Jika Anda mempertahankan Python di Windows, Anda mungkin ingin modul
pihak ketiga berada di subdirektori "*prefix*", bukan tepat di dalam
"*prefix*" itu sendiri. Ini hampir semudah menyesuaikan direktori
instalasi skrip---Anda hanya perlu ingat bahwa ada dua jenis modul
yang perlu dikhawatirkan, Python dan modul ekstensi, yang dapat
dikontrol dengan mudah oleh satu opsi:

   python setup.py install --install-lib=Site

Direktori instalasi yang ditentukan relatif terhadap "*prefix*". Tentu
saja, Anda juga harus memastikan bahwa direktori ini berada di path
pencarian modul Python, seperti dengan meletakkan file ".pth" di
direktori situs (lihat "site"). Lihat bagian Memodifikasi Path
Pencarian Python untuk mengetahui cara memodifikasi path pencarian
Python.

Jika Anda ingin menentukan seluruh skema instalasi, Anda hanya perlu
menyediakan semua opsi direktori instalasi. Cara yang disarankan untuk
melakukan ini adalah dengan menyediakan path relatif; misalnya, jika
Anda ingin mempertahankan semua file terkait modul Python di bawah
"python" di direktori home Anda, dan Anda ingin direktori terpisah
untuk setiap platform tempat Anda menggunakan direktori home, Anda
dapat menentukan skema instalasi berikut:

   python setup.py install --home=~ \
                           --install-purelib=python/lib \
                           --install-platlib=python/lib.$PLAT \
                           --install-scripts=python/scripts
                           --install-data=python/data

atau, setara,

   python setup.py install --home=~/python \
                           --install-purelib=lib \
                           --install-platlib='lib.$PLAT' \
                           --install-scripts=scripts
                           --install-data=data

"$PLAT" bukanlah (harus) variabel environment---itu akan diperluas
oleh Distutils saat ia mem-parsing opsi baris perintah Anda, seperti
yang dilakukannya saat mem-parsing file konfigurasi Anda.

Jelas, menentukan seluruh skema instalasi setiap kali Anda menginstal
distribusi modul baru akan sangat membosankan. Dengan demikian, Anda
dapat meletakkan opsi ini ke dalam file konfigurasi Distutils Anda
(lihat bagian File Konfigurasi Distutils):

   [install]
   install-base=$HOME
   install-purelib=python/lib
   install-platlib=python/lib.$PLAT
   install-scripts=python/scripts
   install-data=python/data

atau, setara,

   [install]
   install-base=$HOME/python
   install-purelib=lib
   install-platlib=lib.$PLAT
   install-scripts=scripts
   install-data=data

Perhatikan bahwa keduanya *tidak* setara jika Anda menyediakan
direktori dasar penginstalan yang berbeda saat Anda menjalankan skrip
penataan. Sebagai contoh,:

   python setup.py install --install-base=/tmp

akan menginstal modul murni ke "/tmp/python/lib" dalam kasus pertama,
dan ke "/tmp/lib" dalam kasus kedua. (Untuk kasus kedua, Anda mungkin
ingin menyediakan basis instalasi "/tmp/python".)

Anda mungkin memperhatikan penggunaan "$HOME" dan "$PLAT" di sampel
input file konfigurasi. Ini adalah variabel konfigurasi Distutils,
yang memiliki kemiripan yang kuat dengan variabel environment.
Faktanya, Anda dapat menggunakan variabel environment dalam file
konfigurasi pada platform yang memiliki gagasan seperti itu tetapi
Distutils juga menetapkan beberapa variabel tambahan yang mungkin
tidak ada di environment Anda, seperti "$PLAT". (Dan tentu saja, pada
sistem yang tidak memiliki variabel environment, seperti Mac OS 9,
variabel konfigurasi yang disediakan oleh Distutils adalah satu-
satunya yang dapat Anda gunakan.) Lihat bagian File Konfigurasi
Distutils untuk detailnya.

Catatan:

  Ketika a virtual environment diaktifkan, setiap opsi yang mengubah
  path instalasi akan diabaikan dari semua file konfigurasi distutils
  untuk mencegah penginstalan proyek di luar lingkungan virtual secara
  tidak sengaja.


Memodifikasi Path Pencarian Python
----------------------------------

Ketika interpreter Python menjalankan "import", ia mencari kode Python
dan modul ekstensi di sepanjang path pencarian. Nilai default untuk
path dikonfigurasikan ke dalam biner Python saat interpreter dibuat.
Anda dapat menentukan path dengan mengimport modul "sys" dan mencetak
nilai "sys.path".:

   $ python
   Python 2.2 (#11, Oct  3 2002, 13:31:27)
   [GCC 2.96 20000731 (Red Hat Linux 7.3 2.96-112)] on linux2
   Type "help", "copyright", "credits" or "license" for more information.
   >>> import sys
   >>> sys.path
   ['', '/usr/local/lib/python2.3', '/usr/local/lib/python2.3/plat-linux2',
    '/usr/local/lib/python2.3/lib-tk', '/usr/local/lib/python2.3/lib-dynload',
    '/usr/local/lib/python2.3/site-packages']
   >>>

String null dalam "sys.path" mewakili direktori kerja saat ini.

Konvensi yang diharapkan untuk paket yang diinstal secara lokal adalah
dengan meletakkannya di direktori "*...*/site-packages/", tetapi Anda
mungkin ingin menginstal modul Python ke dalam direktori arbitrer.
Misalnya, situs Anda mungkin memiliki konvensi untuk menyimpan semua
perangkat lunak yang terkait dengan server web di bawah "/www". Add-on
modul Python mungkin termasuk dalam "/www/python", dan untuk
mengimpornya, direktori ini harus ditambahkan ke "sys.path". Ada
beberapa cara berbeda untuk menambahkan direktori.

Cara yang paling mudah adalah dengan menambahkan path file konfigurasi
ke direktori yang sudah ada di path Python, biasanya ke direktori
".../site-packages/". File konfigurasi path memiliki ekstensi ".pth",
dan setiap baris harus berisi satu path yang akan ditambahkan ke
"sys.path". (Karena path baru ditambahkan ke "sys.path", modul dalam
direktori yang ditambahkan tidak akan menimpa modul standar. Ini
berarti Anda tidak dapat menggunakan mekanisme ini untuk menginstal
versi tetap dari modul standar.)

Path bisa absolut atau relatif, dalam hal ini mereka relatif terhadap
direktori yang berisi file ".pth". Lihat dokumentasi modul "site"
untuk informasi lebih lanjut.

Cara yang sedikit kurang nyaman adalah dengan mengedit file "site.py"
di pustaka standar Python, dan memodifikasi "sys.path". "site.py"
secara otomatis diimpor saat interpreter Python dijalankan, kecuali
jika opsi "-S" disediakan untuk menahan perilaku ini. Jadi Anda cukup
mengedit "site.py" dan menambahkan dua baris padanya:

   import sys
   sys.path.append('/www/python/')

Namun, jika Anda menginstal ulang versi utama Python yang sama
(mungkin saat meningkatkan dari 2.2 ke 2.2.2, misalnya) "site.py" akan
ditimpa oleh versi stok. Anda harus ingat bahwa itu telah diubah dan
menyimpan salinannya sebelum melakukan instalasi.

Ada dua variabel environment yang dapat mengubah "sys.path".
"PYTHONHOME" menetapkan nilai alternatif untuk prefiks instalasi
Python. Misalnya, jika "PYTHONHOME" disetel ke "/www/python", path
pencarian akan disetel ke "['', '/www/python/lib/pythonX.Y/',
'/www/python/lib/pythonX.Y/plat-linux2', ...]".

Variabel "PYTHONPATH" dapat disetel ke daftar path yang akan
ditambahkan ke awal "sys.path". Misalnya, jika "PYTHONPATH" disetel ke
"/www/python:/opt/py", pencarian path akan dimulai dengan
"['/www/python', '/opt/py']". (Perhatikan bahwa direktori harus ada
agar dapat ditambahkan ke "sys.path"; modul "site" menghapus path yang
tidak ada.)

Akhirnya, "sys.path" hanyalah daftar Python biasa, jadi aplikasi
Python apa pun dapat memodifikasinya dengan menambahkan atau menghapus
entri.


File Konfigurasi Distutils
==========================

Seperti disebutkan di atas, Anda dapat menggunakan file konfigurasi
Distutils untuk merekam preferensi pribadi atau situs untuk setiap
opsi Distutils. Artinya, opsi apa pun untuk perintah apa pun dapat
disimpan di salah satu dari dua atau tiga file konfigurasi (bergantung
pada platform Anda), yang akan dikonsultasikan sebelum baris perintah
diurai. Ini berarti bahwa file konfigurasi akan menimpa nilai default,
dan baris perintah pada gilirannya akan menimpa file konfigurasi.
Selain itu, jika beberapa file konfigurasi diterapkan, nilai dari file
"sebelumnya" akan ditimpa oleh file "nantinya".


Lokasi dan nama file konfigurasi
--------------------------------

Nama dan lokasi file konfigurasi sedikit berbeda di setiap platform.
Di Unix dan Mac OS X, tiga file konfigurasi (sesuai urutan prosesnya)
adalah:

+----------------+------------------------------------------------------------+---------+
| Tipe file      | Lokasi dan nama file                                       | Catatan |
|================|============================================================|=========|
| system         | "*prefix*/lib/python*ver*/distutils/distutils.cfg"         | (1)     |
+----------------+------------------------------------------------------------+---------+
| personal       | "$HOME/.pydistutils.cfg"                                   | (2)     |
+----------------+------------------------------------------------------------+---------+
| lokal          | "setup.cfg"                                                | (3)     |
+----------------+------------------------------------------------------------+---------+

Dan di Windows, file konfigurasinya adalah:

+----------------+---------------------------------------------------+---------+
| Tipe file      | Lokasi dan nama file                              | Catatan |
|================|===================================================|=========|
| system         | "*prefix*\Lib\distutils\distutils.cfg"            | (4)     |
+----------------+---------------------------------------------------+---------+
| personal       | "%HOME%\pydistutils.cfg"                          | (5)     |
+----------------+---------------------------------------------------+---------+
| lokal          | "setup.cfg"                                       | (3)     |
+----------------+---------------------------------------------------+---------+

Di semua platform, file "pribadi" dapat dinonaktifkan sementara dengan
memberikan opsi *--no-user-cfg*.

Catatan:

1. Sebenarnya, file konfigurasi seluruh sistem berada di direktori
   tempat Distutils diinstal; di bawah Python 1.6 dan yang lebih baru
   di Unix, ini seperti yang ditunjukkan. Untuk Python 1.5.2,
   Distutils biasanya akan diinstal ke
   "*prefix*/lib/python1.5/site-/distutils", jadi file konfigurasi
   sistem harus diletakkan di sana dengan Python 1.5.2.

2. Pada Unix, jika variabel environment "HOME" tidak ditentukan,
   direktori home pengguna akan ditentukan dengan fungsi "getpwuid()"
   dari modul standar "pwd". Ini dilakukan oleh fungsi
   "os.path.expanduser()" yang digunakan oleh Distutils.

3. Yaitu, di direktori saat ini (biasanya lokasi skrip pengaturan).

4. (Lihat juga catatan (1).) Di bawah Python 1.6 dan yang lebih baru,
   "prefiks instalasi" default Python adalah "C:\Python", jadi file
   konfigurasi sistem biasanya "C:\PythonLib\distutils\distutils.cfg".
   Di bawah Python 1.5.2, prefiks defaultnya adalah "C:\Program
   Files\Python", dan Distutils bukan bagian dari standar pustaka---
   jadi file konfigurasi sistemnya adalah "C:\Program
   Files\Python\distutils\distutils.cfg" dalam instalasi Python 1.5.2
   standar pada Windows.

5. Pada Windows, jika variabel environment "HOME" tidak ditentukan,
   "USERPROFILE" maka "HOMEDRIVE" dan "HOMEPATH" akan dicoba. Ini
   dilakukan oleh fungsi "os.path.expanduser()" yang digunakan oleh
   Distutils.


Sintaks file konfigurasi
------------------------

Semua file konfigurasi Distutils memiliki sintaks yang sama. File
konfigurasi dikelompokkan menjadi beberapa bagian. Ada satu bagian
untuk setiap perintah Distutils, ditambah bagian "global" untuk opsi
global yang memengaruhi setiap perintah. Setiap bagian terdiri dari
satu opsi per baris, ditentukan sebagai "option=value".

Misalnya, berikut ini adalah file konfigurasi lengkap yang memaksa
semua perintah untuk berjalan diam-diam secara default:

   [global]
   verbose=0

Jika ini dipasang sebagai file konfigurasi sistem, ini akan
memengaruhi semua pemrosesan distribusi modul Python oleh pengguna
mana pun di sistem saat ini. Jika diinstal sebagai file konfigurasi
pribadi Anda (pada sistem yang mendukungnya), ini hanya akan
memengaruhi distribusi modul yang diproses oleh Anda. Dan jika
digunakan sebagai "setup.cfg" untuk distribusi modul tertentu, ini
hanya mempengaruhi distribusi tersebut.

Anda dapat menimpa direktori "build base" default dan membuat perintah
**build*** selalu secara paksa membangun kembali semua file dengan
yang berikut ini:

   [build]
   build-base=blib
   force=1

yang sesuai dengan argumen baris perintah

   python setup.py build --build-base=blib --force

kecuali itu menyertakan perintah **build** pada baris perintah berarti
bahwa perintah akan dijalankan. Memasukkan perintah tertentu dalam
file konfigurasi tidak memiliki implikasi seperti itu; ini hanya
berarti bahwa jika perintah dijalankan, opsi di file konfigurasi akan
diterapkan. (Atau jika perintah lain yang memperoleh nilai darinya
dijalankan, perintah tersebut akan menggunakan nilai di file
konfigurasi.)

Anda dapat menemukan daftar lengkap opsi untuk setiap perintah
menggunakan opsi "--help", misalnya:

   python setup.py build --help

dan Anda dapat mengetahui daftar lengkap opsi global dengan
menggunakan "--help" tanpa perintah:

   python setup.py --help

Lihat juga bagian "Referensi" dari manual "Mendistribusikan Modul
Python".


Membangun Ekstensi: Tip dan Trik
================================

Jika memungkinkan, Distutils mencoba menggunakan informasi konfigurasi
yang disediakan oleh interpreter Python yang digunakan untuk
menjalankan skrip "setup.py". Misalnya, penanda compiler dan linker
yang sama yang digunakan untuk mengompilasi Python juga akan digunakan
untuk mengompilasi ekstensi. Biasanya ini akan bekerja dengan baik,
tetapi dalam situasi yang rumit ini mungkin tidak tepat. Bagian ini
membahas cara mengganti perilaku Distutils yang biasa.


Menyesuaikan penanda compiler/linker
------------------------------------

Mengompilasi ekstensi Python yang ditulis dalam C atau C ++ kadang-
kadang akan memerlukan spesifikasi penanda khusus untuk compiler dan
linker untuk menggunakan library tertentu atau menghasilkan jenis kode
objek khusus. Ini terutama benar jika ekstensi belum diuji pada
platform Anda, atau jika Anda mencoba mengkompilasi silang Python.

Dalam kasus yang paling umum, pembuat ekstensi mungkin telah
memperkirakan bahwa kompilasi ekstensi akan menjadi rumit, dan
menyediakan file "Setup" file untuk Anda edit. Ini kemungkinan besar
hanya akan dilakukan jika distribusi modul berisi banyak modul
ekstensi terpisah, atau jika mereka sering membutuhkan kumpulan tanda
compiler yang rumit agar dapat berfungsi.

File "Setup", jika ada, diurai untuk mendapatkan daftar ekstensi yang
akan dibuat. Setiap baris dalam "Setup" menjelaskan modul tunggal.
Garis memiliki struktur berikut:

   module ... [sourcefile ...] [cpparg ...] [library ...]

Mari kita periksa masing-masing bidang secara bergantian.

* *module* adalah nama modul ekstensi yang akan dibuat, dan harus
  merupakan Python identifier yang valid. Anda tidak bisa begitu saja
  mengubah ini untuk mengganti nama modul (pengeditan ke kode sumber
  juga akan diperlukan), jadi ini harus dibiarkan saja.

* *sourcefile* adalah segala sesuatu yang cenderung menjadi file kode
  sumber, setidaknya dilihat dari nama filenya. Nama file yang
  diakhiri dengan ".c" diasumsikan ditulis dalam C, nama file yang
  diakhiri dengan ".C", ".cc", dan ".c++" diasumsikan sebagai C++, dan
  nama file yang diakhiri dengan ".m" atau ".mm" diasumsikan berada
  dalam Objective C.

* *cpparg* adalah argumen untuk preprocessor C, dan apa pun yang
  dimulai dengan "-I", "-D", "-U" atau :option:>>`<<!-C >>`<<.

* *library* adalah apapun yang diakhiri dengan ".a" atau dimulai
  dengan "-l" atau "-L".

Jika platform tertentu memerlukan pustaka khusus pada platform Anda,
Anda dapat menambahkannya dengan mengedit file "Setup" dan menjalankan
"python setup.py build". Misalnya, jika modul ditentukan oleh baris:

   foo foomodule.c

harus ditautkan dengan pustaka math "libm.a" pada platform Anda, cukup
tambahkan "-lm" ke baris:

   foo foomodule.c -lm

Sakelar arbitrer yang ditujukan untuk compiler atau linker dapat
diberikan dengan opsi "-Xcompiler" *arg* dan opsi "-Xlinker" *arg*:

   foo foomodule.c -Xcompiler -o32 -Xlinker -shared -lm

Opsi berikutnya setelah "-Xcompiler" dan "-Xlinker" akan ditambahkan
ke baris perintah yang tepat, jadi pada contoh di atas kompilator akan
diberikan opsi "-o32", dan penaut akan diberikan "-shared". Jika opsi
kompilator membutuhkan sebuah argumen, Anda harus menyediakan beberapa
opsi "-Xcompiler"; misalnya, untuk meneruskan "-x c++" file "Setup"
harus berisi "-Xcompiler -x -Xcompiler c++".

Penanda compiler juga bisa diberikan melalui pengaturan variabel
environment "CFLAGS". Jika disetel, konten "CFLAGS" akan ditambahkan
ke penanda kompilator yang ditentukan dalam file "Setup".


Menggunakan kompiler non-Microsoft di Windows
---------------------------------------------


Borland/CodeGear C ++
~~~~~~~~~~~~~~~~~~~~~

Subbagian ini menjelaskan langkah-langkah yang diperlukan untuk
menggunakan Distutils dengan compiler Borland C++ versi 5.5. Pertama-
tama Anda harus tahu bahwa format file objek (OMF) Borland berbeda
dengan format yang digunakan oleh versi Python yang dapat Anda unduh
dari situs Web Python atau ActiveState. (Python dibuat dengan
Microsoft Visual C++, yang menggunakan COFF sebagai format file
objek.) Untuk alasan ini, Anda harus mengonversi pustaka Pythonv
"python25.lib" ke dalam format Borland. Anda dapat melakukan ini
sebagai berikut:

   coff2omf python25.lib python25_bcpp.lib

Program "coff2omf" dilengkapi dengan compiler Borland. File
"python25.lib" ada di direktori "Libs" dari instalasi Python Anda.
Jika ekstensi Anda menggunakan pustaka lain (zlib, ...) Anda juga
harus mengonversinya.

File yang dikonversi harus berada di direktori yang sama dengan
pustaka normal.

Bagaimana Distutils mengelola untuk menggunakan pustaka ini dengan
nama yang berubah? Jika ekstensi memerlukan pustaka (mis. "foo")
Distutils memeriksa terlebih dahulu apakah ia menemukan pustaka dengan
sufiks "_bcpp" (mis. "foo_bcpp.lib") dan kemudian menggunakan pustaka
ini. Dalam kasus ia tidak menemukan pustaka khusus ia menggunakan nama
default ("foo.lib".) [#] _

Untuk mengizinkan Distutils mengkompilasi ekstensi Anda dengan Borland
C++, Anda harus mengetik:

   python setup.py build --compiler=bcpp

Jika Anda ingin menggunakan kompiler Borland C++ sebagai default, Anda
dapat menentukannya di file konfigurasi pribadi atau sistem untuk
Distutils (lihat bagian File Konfigurasi Distutils.)

Lihat juga:

  C++ Builder Compiler
     Informasi tentang compiler C++ gratis dari Borland, termasuk link
     ke halaman download.

  *Membuat Ekstensi Python Menggunakan Kompiler Borland Gratis
  <http://www.cyberus.ca/~g_will/pyExtenDL.shtml>* _
     Dokumen yang menjelaskan cara menggunakan compiler C++ baris
     perintah gratis dari Borland untuk membuat Python.


GNU C / Cygwin / MinGW
~~~~~~~~~~~~~~~~~~~~~~

Bagian ini menjelaskan langkah-langkah yang diperlukan untuk
menggunakan Distutils dengan kompiler GNU C/C++ di distribusi Cygwin
dan MinGW mereka. [2] Untuk interpreter Python yang dibangun dengan
Cygwin, semuanya harus bekerja tanpa langkah-langkah berikut ini.

Tidak semua ekstensi dapat dibuat dengan MinGW atau Cygwin, tetapi
banyak yang bisa. Ekstensi yang paling mungkin tidak berfungsi adalah
ekstensi yang menggunakan C++ atau bergantung pada ekstensi Microsoft
Visual C.

Untuk mengizinkan Distutils mengkompilasi ekstensi Anda dengan Cygwin,
Anda harus mengetik:

   python setup.py build --compiler=cygwin

dan untuk Cygwin dalam mode no-cygwin [3] atau untuk tipe MinGW:

   python setup.py build --compiler=mingw32

Jika Anda ingin menggunakan salah satu opsi/kompiler ini sebagai
default, Anda harus mempertimbangkan untuk menulisnya di file
konfigurasi pribadi atau seluruh sistem Anda untuk Distutils (lihat
bagian File Konfigurasi Distutils.)


Versi Lama Python dan MinGW
"""""""""""""""""""""""""""

Petunjuk berikut hanya berlaku jika Anda menggunakan versi Python yang
lebih rendah dari 2.4.1 dengan MinGW yang lebih rendah dari 3.0.0
(dengan binutils-2.13.90-20030111-1).

Kompiler ini membutuhkan beberapa pustaka khusus. Tugas ini lebih
kompleks daripada C++ Borland, karena tidak ada program untuk
mengonversi pustaka. Pertama, Anda harus membuat daftar simbol yang
diekspor Python DLL. (Anda dapat menemukan program yang bagus untuk
tugas ini di https://sourceforge.net/projects/mingw/files/MinGW/Exten
sion/pexports/).

   pexports python25.dll >python25.def

Lokasi dari file yang diinstal "python25.dll" akan tergantung pada
opsi instalasi dan versi serta bahasa Windows. Dalam instalasi "hanya
untuk saya", ini akan muncul di root direktori instalasi. Dalam
instalasi bersama, itu akan ditempatkan di direktori sistem.

Kemudian Anda dapat membuat dari informasi ini pustaka impor untuk
gcc.

   /cygwin/bin/dlltool --dllname python25.dll --def python25.def --output-lib libpython25.a

Pustaka yang dihasilkan harus ditempatkan di direktori yang sama
dengan "python25.lib". (Seharusnya direktori "libs" di bawah direktori
instalasi Python Anda.)

Jika ekstensi Anda menggunakan pustaka lain (zlib, ...) Anda mungkin
harus mengonversinya juga. File yang dikonversi harus berada di
direktori yang sama seperti pustaka normal.

Lihat juga:

  Membangun modul Python pada platform MS Windows dengan MinGW
     Informasi tentang membangun pustaka yang diperlukan untuk
     environment MinGW.

-[ Catatan kaki ]-

[1] Ini juga berarti Anda dapat mengganti semua pustaka COFF yang ada
    dengan pustaka OMF dengan nama yang sama.

[2] Check https://www.sourceware.org/cygwin/ and http://www.mingw.org/
    for more information

[3] Maka Anda tidak memiliki emulasi POSIX yang tersedia, tetapi Anda
    juga tidak memerlukan "cygwin1.dll".
