---
title: "Menulis perintah django-admin penyesuaian"
version: 1.9
locale: id
source: https://docs.djangoproject.com/id/1.9/howto/custom-management-commands/
canonical: https://djangodocs.dev/id/1.9/howto/custom-management-commands/
---
# Menulis perintah `django-admin` penyesuaian

Aplikasi dapat mendaftarkan tindakan mereka sendiri dengan `manage.py`. Sebagai contoh, anda mungkin ingin menambahkan sebuah tindakan `manage.py` untuk sebuah aplikasi Django yang anda sedang sebarkan. Dalam dokumen ini, kami akan membangun sebuah penyesuaian perintah `closepoll` untuk aplikasi `polls` dari [tutorial](/id/1.9/intro/tutorial01/).

Untuk melakukan ini, tambahkan direktori `management/commands` ke aplikasi. Django akan mendaftarkan sebuah perintah `manage.py` untuk setiap modul Python dalam direktori tersebut yang namanya tidak dimulai dengan garis bawah. Sebagai contoh:

```
polls/
    __init__.py
    models.py
    management/
        __init__.py
        commands/
            __init__.py
            _private.py
            closepoll.py
    tests.py
    views.py
```

Pada Python 2, pastika menyertakan berkas `__init__.py` dalam kedua direktori `management` dan `management/commands` seperti yang dilakukan diatas atau perintah anda tidak akan ditemukan.

Dalam contoh ini, perintah `closepoll` akan dibuat tersedia pada setiap proyek yang menyertakan aplikasi `polls` dalam [`INSTALLED_APPS`](/id/1.9/ref/settings/#std-setting-INSTALLED_APPS).

Modul `_private.py` tidak akan tersedia sebagai perintah pengelolaan.

Modul `closepoll.py` mempunyai hanya satu persyaratan -- itu harus ditentukan sebuah kelas `Command` yang memperpanjang [`BaseCommand`](#django.core.management.BaseCommand) atau satu dari [subclasses](#ref-basecommand-subclasses) nya.

> **Tulisan berdiri sendiri**
>
> Penyesuaian pengelolaan perintah adalah khususnya berguna untuk menjalankan tulisan berdiri sendiri atau untuk tulisan yang secara berkala dijalankan dari panel kendali UNIX crontab atau Windows  scheduled tasks.

Untuk menerapkan perintah, sunting `polls/management/commands/closepoll.py` untuk kelihatan seperti ini:

```
from django.core.management.base import BaseCommand, CommandError
from polls.models import Question as Poll

class Command(BaseCommand):
    help = 'Closes the specified poll for voting'

    def add_arguments(self, parser):
        parser.add_argument('poll_id', nargs='+', type=int)

    def handle(self, *args, **options):
        for poll_id in options['poll_id']:
            try:
                poll = Poll.objects.get(pk=poll_id)
            except Poll.DoesNotExist:
                raise CommandError('Poll "%s" does not exist' % poll_id)

            poll.opened = False
            poll.save()

            self.stdout.write(self.style.SUCCESS('Successfully closed poll "%s"' % poll_id))
```

> **Changed in Django 1.8**
>
> Sebelum Django 1.8, pengelolaan perintah berdasarkan pada modul [`optparse`](https://docs.python.org/3/library/optparse.html#module-optparse), dan penempatan argumen dilewati dalam `*args` selama argumen pilihan dilewati dalam `**options`. Sekarang pengelolaan perintah tersebut menggunakan [`argparse`](https://docs.python.org/3/library/argparse.html#module-argparse) untuk menguraikan argumen, semua argumen dilewati dalam `**options` secara awal, meskipun nama anda penempatan argumen anda pada `args` (suasana kesesuaian). Anda dianjurkan secara eksklusif menggunakan `**options` untuk perintah baru.

> **Note**
>
> Ketika anda menggunakan pengelolaan perintah dan berharap untuk menyediakan keluaran tempat tuts, anda harus menulis ke `self.stdout` dan `self.stderr`, daripada mencetak ke `stdout` and `stderr` secara langsung. Dengan menggunakan proxi ini, dia menjadi lebih mudah untuk mencoba penyesuaian perintah anda. Catat juga bahwa anda tidak butuh mengakhiri pesan dengan karakter baris baru, dia akan ditambahkan otomatis, meskipun anda menentukan parameter `ending`:
>
> ```
> self.stdout.write("Unterminated line", ending='')
> ```

Perintah penyesuaian baru dapat dipanggil menggunakan `python manage.py closepoll <poll_id>`.

The `handle()` method takes one or more `poll_ids` and sets `poll.opened`
to `False` for each one. If the user referenced any nonexistent polls, a
[`CommandError`](#django.core.management.CommandError) is raised. The `poll.opened` attribute does not exist in
the [tutorial](/id/1.9/intro/tutorial01/) and was added to
`polls.models.Question` for this example.

## Menerima argumen pilihan

`closepoll` yang sama dapat dengan mudah dirubah untuk menghapus jejak pendapat yang diberikan daripada menutupnya dengan menerima tambahan pilihan baris perintah. Penyesuaian pilihan ini dapat ditambahkan dalam cara [`add_arguments()`](#django.core.management.BaseCommand.add_arguments) seperti ini:

```
class Command(BaseCommand):
    def add_arguments(self, parser):
        # Positional arguments
        parser.add_argument('poll_id', nargs='+', type=int)

        # Named (optional) arguments
        parser.add_argument(
            '--delete',
            action='store_true',
            dest='delete',
            default=False,
            help='Delete poll instead of closing it',
        )

    def handle(self, *args, **options):
        # ...
        if options['delete']:
            poll.delete()
        # ...
```

> **Changed in Django 1.8**
>
> Sebelumnya, hanya pustaka [`optparse`](https://docs.python.org/3/library/optparse.html#module-optparse) standar yang didukung dan anda harus memperpanjang perintah variabel `option_list` dengan `optparse.make_option()`.

Pilihan (`delete` dalam contoh kami) tersedia dalam pilihan parameter perintah dari cara penanganan. Lihat dokumentasi Python [`argparse`](https://docs.python.org/3/library/argparse.html#module-argparse) untuk lebih tentang penggunaan `add_argument`.

Dalam tambahan untuk dapat menambahkan penyesuaian pilihan baris perintah, semua [pengelolaan perintah](/id/1.9/ref/django-admin/) dapat menerima beberapa pilihan awal seperti [`--verbosity`](/id/1.9/ref/django-admin/#cmdoption-verbosity) dan [`--traceback`](/id/1.9/ref/django-admin/#cmdoption-traceback).

## Pengelolaan perintah dan lokal

Secara awal, cara [`BaseCommand.execute()`](#django.core.management.BaseCommand.execute) menonaktifkan terjemahan karena beberapa perintah dikemas dengan Django melakukan beberapa tugas (sebagai contoh, membangun isi pengguna muka dan mengumpulkan basisdata) yang membutuhkan bahasa deretan karakter proyek-netral.

> **Changed in Django 1.8**
>
> Dalam versi sebelumnya, Django memaksa lokal "en-us" daripada meniadakan terjemahan.

Jika, untuk beberapa alasan, penyesuaian pengelolaan perintah anda butuh menggunakan lokal yang tetap, anda harus secara manual mengaktif dan menonaktifkannya dalam cara [`handle()`](#django.core.management.BaseCommand.handle) anda menggunakan fungsi disediakan oleh dukungan kode I18N:

```
from django.core.management.base import BaseCommand, CommandError
from django.utils import translation

class Command(BaseCommand):
    ...
    can_import_settings = True

    def handle(self, *args, **options):

        # Activate a fixed locale, e.g. Russian
        translation.activate('ru')

        # Or you can activate the LANGUAGE_CODE # chosen in the settings:
        from django.conf import settings
        translation.activate(settings.LANGUAGE_CODE)

        # Your command logic here
        ...

        translation.deactivate()
```

Kebutuhan lainnya mungkin bahwa perintah anda dengan mudah harus menggunakan kumpulan lokal dalam pengaturan dan Django harus dijaga dari penonaktifannya. Anda dapat mencapainya dengan menggunakan pilihan [`BaseCommand.leave_locale_alone`](#django.core.management.BaseCommand.leave_locale_alone).

Ketika bekerja pada skenario yang digambarkan diatas, perhatikan akun yang sistem pengelolaan perintah khususnya harus sangat waspada tentang berjalan dalam lokal yang tidak seragam, jadi anda mungkin butuh untuk:

- Pastikan pengaturan [`USE_I18N`](/id/1.9/ref/settings/#std-setting-USE_I18N) selalu `True` ketika menjalankan perintah (ini adalah contoh bagus dari potensial masalah berasal dari sebuah lingkungan waktu berjalan dinamis dimana perintah Django menghindari begitu saja dengan menonaktifkan terjemahan).
- Tinjau kode dari perintah anda dan kode dipanggil untuk perbedaan perilaku ketika lokal dirubah dan dinilai dampaknya pada perkiraan kebiasaan dari perintah anda.

## Pengujian

Informasi pada bagaimana untuk mencoba penyesuaian pengelolaan perintah dapat ditemukan dalam [dokumen percobaan](/id/1.9/topics/testing/tools/#topics-testing-management-commands).

## Obyek perintah

#### `class BaseCommand`

Kelas dasar dari mana semua pengelolaan perintah akhirnya berasal.

Gunakan kelas ini jika anda ingin mengakses semua mekanisme yang mengurai argumen baris perintah dan bekerja kode apa untuk dipanggil dalam tanggapan; jika anda tidak butuh merubah kebiasaan apapun, pertimbangkan menggunakan satu dari [subclasses](#ref-basecommand-subclasses) nya.

Mensubkelaskan kelas [`BaseCommand`](#django.core.management.BaseCommand) membutuhkan bahwa anda menerapkan cara [`handle()`](#django.core.management.BaseCommand.handle).

### Atribut

Semua atribut dapat di setel dalam kelas turunan anda dan dapat digunakan dalam [subclasses](#ref-basecommand-subclasses) [`BaseCommand`](#django.core.management.BaseCommand).

#### `BaseCommand.args`

Daftar deretan karakter argumen yang diterima oleh perintah, cocok untuk digunakan dalam pesan bantuan; sebagai contoh, sebuah perintah yang mengambil daftar nama aplikasi mungkin disetel ini menjadi '\<app\_label app\_label ...\>'.

> **Deprecated since Django 1.8**
>
> Ditinggalkan sejak versi 1.8: Ini seharusnya selesai sekarang dalam cara [`add_arguments()`](#django.core.management.BaseCommand.add_arguments), dengan memanggil cara `parser.add_argument()`. Lihat coontoh `closepoll` diatas.

#### `BaseCommand.can_import_settings`

Sebuah boolean menunjukkan apakah perintah butuh dapat mengimpor pengaturan Django; jika `True`, `execute()` akan memeriksa bahwa ini dimungkinkan sebelum dilanjutkan. Nilai awal adalah `True`.

#### `BaseCommand.help`

Deskripsi singkat dari perintah, dimana akan ditampilkan di pesan bantuan ketika pengguna eksekusi perintah `python manage.py help <command>`.

#### `BaseCommand.missing_args_message`

> **New in Django 1.8**

Jika perintah anda menentukan argumen penempatan wajib, anda dapat menyesuaiakan pesan kesalahan yang dikembalikan dalam kasus argumen yang hilang. Awalnya adalah keluaran oleh [`argparse`](https://docs.python.org/3/library/argparse.html#module-argparse) ("terlalu sedikit argumen").

#### `BaseCommand.option_list`

Ini adalah daftar dari pilihan `optparse` yang akan diberi makan kedalam perintah `OptionParser` untuk mengurai argumen.

> **Deprecated since Django 1.8**
>
> Ditinggalkan sejak versi 1.8: Anda harus sekarang mengesampingkan cara [`add_arguments()`](#django.core.management.BaseCommand.add_arguments) untuk menambahkan penyesuaian argumen yang diterima oleh perintah anda. Lihat [contoh diatas](#custom-commands-options).

#### `BaseCommand.output_transaction`

Sebuah boolean menunjukkan apakah perintah keluaran pernyataan SQL; jika `True`, keluaran akan otomatis dibungkus dengan `BEGIN;` dan `COMMIT;`. Nilai awal adalah `False`.

#### `BaseCommand.requires_system_checks`

Sebuah boolean; jika `True`, seluruh proyek Django akan diperiksa untuk masalah potensial sebelum menjalankan perintah. Nilai awal adalah `True`.

#### `BaseCommand.leave_locale_alone`

Sebuah boolean menunjukkan apakah kumpulan lokal dalam pengaturan harus dipertahankan selama menjalankan dari program daripada dipaksa disetel menjadi 'en-us'.

Nilai awal adalah `False`.

Pastikan anda mengetahui apa yang anda sedang mengerjakan jika anda memutuskan nilai dari pilihan ini dalam penyesuaian perintah anda jika dia dibuat basisdata yang bersifat sensitif-lokal dan isi seperti itu tidak harus mengandung terjemahan apapun (seperti itu terjadi sebagai contoh dengan django.contrib.auth permissions) ketika membuat perbedaan lokal dari standar sebenarnya 'en-us' mungkin menyebabkan efek yang tidak diinginkan. Lihat bagian [Management commands and locales](#id1) diatas untuk lebih lanjut.

Pilihan ini tidak dapat `False` ketika pilihan [`can_import_settings`](#django.core.management.BaseCommand.can_import_settings) disetel menjadi `False` juga karena mencoba menyetel lokal butuh akses ke pengaturan. Kondisi ini akan membangkitkan sebuah [`CommandError`](#django.core.management.CommandError).

#### `BaseCommand.style`

Sebuah atribut instance yang membantu membuat keluaran bewarna ketika menulis ke `stdout` atau `stderr`. Sebagai contoh:

```
self.stdout.write(self.style.SUCCESS('...'))
```

Lihat [Syntax coloring](/id/1.9/ref/django-admin/#syntax-coloring) untuk mempelajari bagaimana merubah papan warna dan melihat gaya tersedia (gunakan versi huruf besar dari "roles" yang digambarkan dalam bagian itu).

Jika anda melewati pilihan [`--no-color`](/id/1.9/ref/django-admin/#cmdoption-no-color) ketika menjalankan perintah anda, semua pemanggilan `self.style()` akan mengembalikan deretan karakter asli tidak bewarna.

### Cara

[`BaseCommand`](#django.core.management.BaseCommand) mempunyai beberapa cara yang dapat dikesampingkan tetapi hanya cara [`handle()`](#django.core.management.BaseCommand.handle) harus diterapkan.

> **Menerapkan constructor dalam subkelas**
>
> Jika anda menerapkan `__init__` dalam subkelas anda dari [`BaseCommand`](#django.core.management.BaseCommand), anda harus memanggil `__init__` dari :class:BaseCommand:
>
> ```
> class Command(BaseCommand):
>     def __init__(self, *args, **kwargs):
>         super(Command, self).__init__(*args, **kwargs)
>         # ...
> ```

#### `BaseCommand.add_arguments(parser)`

> **New in Django 1.8**

Titik masukan untuk menambahkan pengurai argumen untuk menangani argumen baris perintah dilewati ke perintah. Penyesuaian perintah harus mengesampingkan cara ini untuk menambah kedua argumen penempatan dan pilihan yang diterima oleh perintah. Memanggil `super()` tidak dibutuhkan ketika pengsubkelasan secara langsung `BaseCommand`.

#### `BaseCommand.get_version()`

Mengembalikan versi Django, yang seharusnya benar untuk semua perintah Django siap pakai. Perintah pasokan-pengguna dapat mengesampingkan cara ini untuk mengembalikan versi mereka sendiri.

#### `BaseCommand.execute(*args, **options)`

Coba untuk menjalankan perintah ini, melakukan pemeriksaan sistem jika dibutuhkan (sebagai pengendalian oleh [`requires_system_checks`](#django.core.management.BaseCommand.requires_system_checks) attribute). Jika perintah muncul sebuah [`CommandError`](#django.core.management.CommandError), Dia dicegat dan dicetak ke stderr.

> **Memanggil perintah pengelolaan di kode anda**
>
> `execute()` jangan dipanggil secara langsung dari kode anda untuk menjalankan sebuah perintah. Lebih baik gunakan [`call_command()`](/id/1.9/ref/django-admin/#django.core.management.call_command).

#### `BaseCommand.handle(*args, **options)`

Logika sebenarnya dari perintah. Subkelas harus menerapkan cara ini.

Dia mungkin mengembalikan sebuah deretan karakter Unicode yang akan dicetak ke `stdout` (dibungkus oleh `BEGIN;` dan `COMMIT;` jika [`output_transaction`](#django.core.management.BaseCommand.output_transaction) adalah `True`).

#### `BaseCommand.check(app_configs=None, tags=None, display_num_errors=False)`

Gunakan kerangka pemeriksaan sistem untuk memeriksa keseluruhan proyek Django untuk masalah potensial. Masalah serius muncul seperti sebuah [`CommandError`](#django.core.management.CommandError); peringatan dikeluarkan ke stderr; pemberitahuan kecil dikeluarkan pada stdout.

Jika `app_configs` dan `tags` keduanya `None`, semua pemeriksaan sistem dilakukan. `tags` dapat menjadi daftar dari etiket pemeriksaan, seperti `compatibility` atau `models`.

### Subkelas `BaseCommand`

#### `class AppCommand`

Sebuah pengelolaan perintah yang mengambil satu atau lebih label aplikasi terpasang sebagai argumen, dan melakukan sesuatu dengan masing-masing dari mereka.

Daripada menerapkan [`handle()`](#django.core.management.BaseCommand.handle),  subkelas harus menerapkan [`handle_app_config()`](#django.core.management.AppCommand.handle_app_config), yang akan dipanggil sekali untuk setiap aplikasi.

#### `AppCommand.handle_app_config(app_config, **options)`

Melakukan tindakan perintah untuk `app_config`, yang akan menjadi sebuah instance [`AppConfig`](/id/1.9/ref/applications/#django.apps.AppConfig) terhubung ke sebuah label aplikasi yang diberikan pada baris perintah.

#### `class LabelCommand`

Sebuah pengelolaan perintah yang mengambil satu atau lebih argumen (label) yang berubah-ubah pada baris perintah, dan melakukan sesuatu dengan masing-masing dari mereka.

Daripada menerapkan [`handle()`](#django.core.management.BaseCommand.handle),  subkelas harus menerapkan [`handle_label()`](#django.core.management.LabelCommand.handle_label), yang akan dipanggil sekali untuk setiap label.

#### `LabelCommand.handle_label(label, **options)`

Melakukan tindakan perintah untuk `label`, yang akan menjadi deretan karakter seperti yang diberikan pada baris perintah.

#### `class NoArgsCommand`

> **Deprecated since Django 1.8**
>
> Ditinggalkan sejak versi 1.8: Gunakan [`BaseCommand`](#django.core.management.BaseCommand), yang tidak mengambil argumen secara awal.

Sebuah perintah yang tidak mengambil argumen dalam baris perintah.

Daripada menerapkan [`handle()`](#django.core.management.BaseCommand.handle),  subkelas harus menerapkan [`handle_noargs()`](#django.core.management.NoArgsCommand.handle_noargs); [`handle()`](#django.core.management.BaseCommand.handle) itu sendiri dikesampingkan untuk memastikan tidak ada argumen dilewatkan ke perintah.

#### `NoArgsCommand.handle_noargs(**options)`

Melakukan tindakan perintah ini

### Perintah pengecualian

#### `exception CommandError`

Kelas pengecualian mengindikasikan sebuah masalah selama menjalankan perintah pengelolaan.

Jika pengecualian ini muncul selama peerjalanan dari pengelolaan perintah dari sebuah perintah baris tempat tuts, dia akan ditangkap dan dirubah menjadi pesan kesalahan tercetak yang bagus ke aliran keluaran yang sesuai (yaitu, stderr); sebagai sebuah hasil, memunculkan pengecualian ini (dengan sebuah gambaran yang mudah dimengerti dari kesalahan) adalah jalan yang dipilih untuk menunjukkan bahwa sesuatu telah salah dalam menjalankan sebuah perintah.

Jika sebuah pengelolaan perintah dipanggil dari kode melalui [`call_command()`](/id/1.9/ref/django-admin/#django.core.management.call_command), itu terserah kamu untuk menangkap pengecualian ketika dibutuhkan.