{"title":"Come creare comandi django-admin personalizzati","version":"5.1","locale":"it","docname":"howto/custom-management-commands","url":"/it/5.1/howto/custom-management-commands/","canonical":"https://djangodocs.dev/it/5.1/howto/custom-management-commands/","summary":"Le applicazioni possono registrare le proprie azioni con manage.py. Per esempio, potresti voler aggiungere una azione manage.py per una applicazione Django…","html":"<span id=\"how-to-create-custom-django-admin-commands\"></span><h1>Come creare comandi <code class=\"docutils literal notranslate\">django-admin</code> personalizzati<a class=\"heading-anchor\" href=\"#module-django.core.management\"><span class=\"visually-hidden\">Link to this heading</span><span aria-hidden=\"true\">#</span></a></h1>\n<p>Le applicazioni possono registrare le proprie azioni con <code class=\"docutils literal notranslate\">manage.py</code>. Per esempio, potresti voler aggiungere una azione <code class=\"docutils literal notranslate\">manage.py</code> per una applicazione Django che stai distribuendo. In questo documento, costruiremo un comando personalizzato <code class=\"docutils literal notranslate\">closepoll</code> per l’applicazione <code class=\"docutils literal notranslate\">polls</code> dal <a class=\"reference internal\" href=\"/it/5.1/intro/tutorial01/\"><span class=\"doc\">tutorial</span></a>.</p>\n<p>To do this, add a <code class=\"docutils literal notranslate\">management/commands</code> directory to the application. Django\nwill register a <code class=\"docutils literal notranslate\">manage.py</code> command for each Python module in that directory\nwhose name doesn’t begin with an underscore. For example:</p>\n<div class=\"code-block\" data-language=\"text\"><div class=\"code-block-toolbar\"><span class=\"code-block-language\">Text</span><button type=\"button\" class=\"copy-button\" data-copy hidden><span class=\"copy-button-label\">Copy</span></button></div><pre role=\"group\" tabindex=\"0\" aria-label=\"Text code\"><code>polls/\n    __init__.py\n    models.py\n    management/\n        __init__.py\n        commands/\n            __init__.py\n            _private.py\n            closepoll.py\n    tests.py\n    views.py\n</code></pre></div>\n<p>In questo esempio, il comando <code class=\"docutils literal notranslate\">closepoll</code> sarà reso disponibile a qualsiasi progetto che includa l’applicazione <code class=\"docutils literal notranslate\">polls</code> in <a class=\"reference internal\" href=\"/it/5.1/ref/settings/#std-setting-INSTALLED_APPS\"><code class=\"xref std std-setting docutils literal notranslate\">INSTALLED_APPS</code></a>.</p>\n<p>Il modulo <code class=\"docutils literal notranslate\">_private.py</code> non sarà disponibile come comando di management.</p>\n<p>Il modulo <code class=\"docutils literal notranslate\">closepoll.py</code> ha un solo requisito – deve definire una classe <code class=\"docutils literal notranslate\">Command</code> che estenda <a class=\"reference internal\" href=\"#django.core.management.BaseCommand\" title=\"django.core.management.BaseCommand\"><code class=\"xref py py-class docutils literal notranslate\">BaseCommand</code></a> o una delle sue <a class=\"reference internal\" href=\"#ref-basecommand-subclasses\"><span class=\"std std-ref\">sottoclassi</span></a>.</p>\n<aside class=\"admonition-standalone-scripts admonition\" role=\"note\">\n<p class=\"admonition-title\">Script standalone</p>\n<p>Il comandi di management personalizzati sono utili soprattutto per lanciare script standalone o per script che sono eseguiti periodicamente con il crontab di UNIX o dal pannello di controllo per la pianificazione dei task di Windows.</p>\n</aside>\n<p>Per implementare il comando, modifica <code class=\"docutils literal notranslate\">polls/management/commands/closepoll.py</code> in questo modo :</p>\n<div class=\"code-block\" data-language=\"default\"><div class=\"code-block-toolbar\"><span class=\"code-block-language\">Code</span><button type=\"button\" class=\"copy-button\" data-copy hidden><span class=\"copy-button-label\">Copy</span></button></div><pre role=\"group\" tabindex=\"0\" aria-label=\"Code code\"><code><span class=\"kn\">from</span> <span class=\"nn\">django.core.management.base</span> <span class=\"kn\">import</span> BaseCommand<span class=\"p\">,</span> CommandError\n<span class=\"kn\">from</span> <span class=\"nn\">polls.models</span> <span class=\"kn\">import</span> Question <span class=\"k\">as</span> Poll\n\n\n<span class=\"k\">class</span> <span class=\"nc\">Command</span><span class=\"p\">(</span>BaseCommand<span class=\"p\">):</span>\n    help <span class=\"o\">=</span> <span class=\"s2\">&quot;Closes the specified poll for voting&quot;</span>\n\n    <span class=\"k\">def</span> <span class=\"nf\">add_arguments</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"p\">,</span> parser<span class=\"p\">):</span>\n        parser<span class=\"o\">.</span>add_argument<span class=\"p\">(</span><span class=\"s2\">&quot;poll_ids&quot;</span><span class=\"p\">,</span> nargs<span class=\"o\">=</span><span class=\"s2\">&quot;+&quot;</span><span class=\"p\">,</span> <span class=\"nb\">type</span><span class=\"o\">=</span><span class=\"nb\">int</span><span class=\"p\">)</span>\n\n    <span class=\"k\">def</span> <span class=\"nf\">handle</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"p\">,</span> <span class=\"o\">*</span>args<span class=\"p\">,</span> <span class=\"o\">**</span>options<span class=\"p\">):</span>\n        <span class=\"k\">for</span> poll_id <span class=\"ow\">in</span> options<span class=\"p\">[</span><span class=\"s2\">&quot;poll_ids&quot;</span><span class=\"p\">]:</span>\n            <span class=\"k\">try</span><span class=\"p\">:</span>\n                poll <span class=\"o\">=</span> Poll<span class=\"o\">.</span>objects<span class=\"o\">.</span>get<span class=\"p\">(</span>pk<span class=\"o\">=</span>poll_id<span class=\"p\">)</span>\n            <span class=\"k\">except</span> Poll<span class=\"o\">.</span>DoesNotExist<span class=\"p\">:</span>\n                <span class=\"k\">raise</span> CommandError<span class=\"p\">(</span><span class=\"s1\">&#39;Poll &quot;</span><span class=\"si\">%s</span><span class=\"s1\">&quot; does not exist&#39;</span> <span class=\"o\">%</span> poll_id<span class=\"p\">)</span>\n\n            poll<span class=\"o\">.</span>opened <span class=\"o\">=</span> <span class=\"kc\">False</span>\n            poll<span class=\"o\">.</span>save<span class=\"p\">()</span>\n\n            <span class=\"bp\">self</span><span class=\"o\">.</span>stdout<span class=\"o\">.</span>write<span class=\"p\">(</span>\n                <span class=\"bp\">self</span><span class=\"o\">.</span>style<span class=\"o\">.</span>SUCCESS<span class=\"p\">(</span><span class=\"s1\">&#39;Successfully closed poll &quot;</span><span class=\"si\">%s</span><span class=\"s1\">&quot;&#39;</span> <span class=\"o\">%</span> poll_id<span class=\"p\">)</span>\n            <span class=\"p\">)</span>\n</code></pre></div>\n<aside class=\"admonition admonition-note\" id=\"management-commands-output\" role=\"note\">\n<p class=\"admonition-title\">Nota</p>\n<p>Quando utilizzi i comandi di management personalizzati e vuoi ottenere dell’output su console, dovresti scrivere su <code class=\"docutils literal notranslate\">self.stdout</code> e <code class=\"docutils literal notranslate\">self.stderr</code>, invece che direttamente su stdout` and <code class=\"docutils literal notranslate\">stderr</code>. Utilizzando questi proxy, diventa molto più facile testare il tuo comando personalizzato. Nota anache che non hai bisogno di terminare i messaggi con il carattere di newline, sarà aggiunto automaticamente, a meno che tu non specifichi il parametro <code class=\"docutils literal notranslate\">ending</code>:</p>\n<div class=\"code-block\" data-language=\"default\"><div class=\"code-block-toolbar\"><span class=\"code-block-language\">Code</span><button type=\"button\" class=\"copy-button\" data-copy hidden><span class=\"copy-button-label\">Copy</span></button></div><pre role=\"group\" tabindex=\"0\" aria-label=\"Code code\"><code><span class=\"bp\">self</span><span class=\"o\">.</span>stdout<span class=\"o\">.</span>write<span class=\"p\">(</span><span class=\"s2\">&quot;Unterminated line&quot;</span><span class=\"p\">,</span> ending<span class=\"o\">=</span><span class=\"s2\">&quot;&quot;</span><span class=\"p\">)</span>\n</code></pre></div>\n</aside>\n<p>Il nuovo comando personalizzato potrà essere chiamato con <code class=\"docutils literal notranslate\">python manage.py closepoll &lt;poll_ids&gt;</code>.</p>\n<p>Il metodo <code class=\"docutils literal notranslate\">handle()</code> prende uno o più <code class=\"docutils literal notranslate\">poll_ids</code> ed imposta <code class=\"docutils literal notranslate\">poll.opened</code> a <code class=\"docutils literal notranslate\">False</code> per ognuno di essi. Se l’utente fa riferimento ad un poll non esistente, viene sollevato un <a class=\"reference internal\" href=\"#django.core.management.CommandError\" title=\"django.core.management.CommandError\"><code class=\"xref py py-exc docutils literal notranslate\">CommandError</code></a>. L’attributo <code class=\"docutils literal notranslate\">poll.opened</code> non esiste nel <a class=\"reference internal\" href=\"/it/5.1/intro/tutorial02/\"><span class=\"doc\">tutorial</span></a>  ed è stato aggiunto a <code class=\"docutils literal notranslate\">polls.models.Question</code> per questo esempio.</p>\n<section id=\"accepting-optional-arguments\">\n<span id=\"custom-commands-options\"></span><h2>Accetta argomenti opzionali<a class=\"heading-anchor\" href=\"#accepting-optional-arguments\"><span class=\"visually-hidden\">Link to this heading</span><span aria-hidden=\"true\">#</span></a></h2>\n<p>Lo stesso <code class=\"docutils literal notranslate\">closepoll</code>  può essere modificato facilmente per cancellare un dato poll invece che chiuderlo accettando opzioni sulla command line. Queste opzioni personalizzate possono essere aggiunte nel metodo <a class=\"reference internal\" href=\"#django.core.management.BaseCommand.add_arguments\" title=\"django.core.management.BaseCommand.add_arguments\"><code class=\"xref py py-meth docutils literal notranslate\">add_arguments()</code></a> così:</p>\n<div class=\"code-block\" data-language=\"default\"><div class=\"code-block-toolbar\"><span class=\"code-block-language\">Code</span><button type=\"button\" class=\"copy-button\" data-copy hidden><span class=\"copy-button-label\">Copy</span></button></div><pre role=\"group\" tabindex=\"0\" aria-label=\"Code code\"><code><span class=\"k\">class</span> <span class=\"nc\">Command</span><span class=\"p\">(</span>BaseCommand<span class=\"p\">):</span>\n    <span class=\"k\">def</span> <span class=\"nf\">add_arguments</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"p\">,</span> parser<span class=\"p\">):</span>\n        <span class=\"c1\"># Positional arguments</span>\n        parser<span class=\"o\">.</span>add_argument<span class=\"p\">(</span><span class=\"s2\">&quot;poll_ids&quot;</span><span class=\"p\">,</span> nargs<span class=\"o\">=</span><span class=\"s2\">&quot;+&quot;</span><span class=\"p\">,</span> <span class=\"nb\">type</span><span class=\"o\">=</span><span class=\"nb\">int</span><span class=\"p\">)</span>\n\n        <span class=\"c1\"># Named (optional) arguments</span>\n        parser<span class=\"o\">.</span>add_argument<span class=\"p\">(</span>\n            <span class=\"s2\">&quot;--delete&quot;</span><span class=\"p\">,</span>\n            action<span class=\"o\">=</span><span class=\"s2\">&quot;store_true&quot;</span><span class=\"p\">,</span>\n            help<span class=\"o\">=</span><span class=\"s2\">&quot;Delete poll instead of closing it&quot;</span><span class=\"p\">,</span>\n        <span class=\"p\">)</span>\n\n    <span class=\"k\">def</span> <span class=\"nf\">handle</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"p\">,</span> <span class=\"o\">*</span>args<span class=\"p\">,</span> <span class=\"o\">**</span>options<span class=\"p\">):</span>\n        <span class=\"c1\"># ...</span>\n        <span class=\"k\">if</span> options<span class=\"p\">[</span><span class=\"s2\">&quot;delete&quot;</span><span class=\"p\">]:</span>\n            poll<span class=\"o\">.</span>delete<span class=\"p\">()</span>\n        <span class=\"c1\"># ...</span>\n</code></pre></div>\n<p>L’opzione (<code class=\"docutils literal notranslate\">delete</code> nel nostro esempio) è disponibile nel dizionario di parametri delle opzioni del metodo handle. Vedi la documentazione di Python di <a class=\"reference external\" href=\"https://docs.python.org/3/library/argparse.html#module-argparse\" title=\"(in Python v3.14)\"><code class=\"xref py py-mod docutils literal notranslate\">argparse</code></a> per saperne di più sull’utilizzo di <code class=\"docutils literal notranslate\">add_argument</code>.</p>\n<p>Oltre ad essere in grado di aggiungere opzioni personalizzate per la command line, tutti i <a class=\"reference internal\" href=\"/it/5.1/ref/django-admin/\"><span class=\"doc\">comandi di management</span></a>  possono accettare alcune opzioni di default come <a class=\"reference internal\" href=\"/it/5.1/ref/django-admin/#cmdoption-verbosity\"><code class=\"xref std std-option docutils literal notranslate\">--verbosity</code></a> e  <a class=\"reference internal\" href=\"/it/5.1/ref/django-admin/#cmdoption-traceback\"><code class=\"xref std std-option docutils literal notranslate\">--traceback</code></a>.</p>\n</section>\n<section id=\"management-commands-and-locales\">\n<span id=\"id1\"></span><h2>Commandi di gestione e traduzioni/locale<a class=\"heading-anchor\" href=\"#management-commands-and-locales\"><span class=\"visually-hidden\">Link to this heading</span><span aria-hidden=\"true\">#</span></a></h2>\n<p>Di default, i comandi di management sono eseguiti con il locale che è correntemente attivo.</p>\n<p>Se, per qualche ragione, il tuo comando di management personalizzato deve girare senza un locale attivo (per esempio, per evitare che il contenuto tradotto venga inserito nel database), disattiva le traduzioni usando il decoratore <code class=\"docutils literal notranslate\">&#64;no_translations</code>  sul tuo metodo <a class=\"reference internal\" href=\"#django.core.management.BaseCommand.handle\" title=\"django.core.management.BaseCommand.handle\"><code class=\"xref py py-meth docutils literal notranslate\">handle()</code></a></p>\n<div class=\"code-block\" data-language=\"default\"><div class=\"code-block-toolbar\"><span class=\"code-block-language\">Code</span><button type=\"button\" class=\"copy-button\" data-copy hidden><span class=\"copy-button-label\">Copy</span></button></div><pre role=\"group\" tabindex=\"0\" aria-label=\"Code code\"><code><span class=\"kn\">from</span> <span class=\"nn\">django.core.management.base</span> <span class=\"kn\">import</span> BaseCommand<span class=\"p\">,</span> no_translations\n\n\n<span class=\"k\">class</span> <span class=\"nc\">Command</span><span class=\"p\">(</span>BaseCommand<span class=\"p\">):</span>\n    <span class=\"o\">...</span>\n\n    <span class=\"nd\">@no_translations</span>\n    <span class=\"k\">def</span> <span class=\"nf\">handle</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"p\">,</span> <span class=\"o\">*</span>args<span class=\"p\">,</span> <span class=\"o\">**</span>options<span class=\"p\">):</span> <span class=\"o\">...</span>\n</code></pre></div>\n<p>Dal momento che la disattivazione della traduzione richiede l’accesso alle impostazioni di configurazione, il decoratore non può essere usato per comandi che funzionino senza impostazioni di configurazione.</p>\n</section>\n<section id=\"testing\">\n<h2>Testing<a class=\"heading-anchor\" href=\"#testing\"><span class=\"visually-hidden\">Link to this heading</span><span aria-hidden=\"true\">#</span></a></h2>\n<p>Informazioni su come testare i comandi di management personalizzati possono essere trovate nei <a class=\"reference internal\" href=\"/it/5.1/topics/testing/tools/#topics-testing-management-commands\"><span class=\"std std-ref\">documenti di testing</span></a>.</p>\n</section>\n<section id=\"overriding-commands\">\n<h2>Override dei comandi<a class=\"heading-anchor\" href=\"#overriding-commands\"><span class=\"visually-hidden\">Link to this heading</span><span aria-hidden=\"true\">#</span></a></h2>\n<p>Django registra i comandi built-in e poi cerca comandi in <a class=\"reference internal\" href=\"/it/5.1/ref/settings/#std-setting-INSTALLED_APPS\"><code class=\"xref std std-setting docutils literal notranslate\">INSTALLED_APPS</code></a> in senso inverso. Durante la ricerca, se un nome di comando duplica un comando già registrato, fa override su quello precedente.</p>\n<p>In altre parole, per fare override di un comando, il nuovo comando deve avere lo stesso nome e la sua app deve trovarsi prima di quella del comando su cui fare override in <a class=\"reference internal\" href=\"/it/5.1/ref/settings/#std-setting-INSTALLED_APPS\"><code class=\"xref std std-setting docutils literal notranslate\">INSTALLED_APPS</code></a>.</p>\n<p>I comandi di management di app di terze parti che sono stati sovrascritti in modo non intenzionale posso essere resi disponibili con un nuovo nome creando un nuovo comando in una delle app del tuo progetto (che si trovi in ordine prima dell’app di terze parti in <a class=\"reference internal\" href=\"/it/5.1/ref/settings/#std-setting-INSTALLED_APPS\"><code class=\"xref std std-setting docutils literal notranslate\">INSTALLED_APPS</code></a>) che importi il <code class=\"docutils literal notranslate\">Command</code> del comando sovrascritto.</p>\n</section>\n<section id=\"command-objects\">\n<h2>Oggetti Command<a class=\"heading-anchor\" href=\"#command-objects\"><span class=\"visually-hidden\">Link to this heading</span><span aria-hidden=\"true\">#</span></a></h2>\n<dl class=\"py class\">\n<dt class=\"sig sig-object py\" id=\"django.core.management.BaseCommand\">\n<em class=\"property\"><span class=\"k\">class</span> </em><span class=\"sig-name descname\">BaseCommand</span><a class=\"heading-anchor\" href=\"#django.core.management.BaseCommand\"><span class=\"visually-hidden\">Link to this definition</span><span aria-hidden=\"true\">#</span></a></dt>\n<dd></dd></dl>\n\n<p>La classe di base da cui, in ultima analisi, tutti i comandi di management derivano.</p>\n<p>Usa questa classe se vuoi accedere a tutti i meccanismi che fanno parsing degli argomenti di command-line e cercano di capire quale codice chiamare in risposta; se non hai bisogno di cambiare questo comportamento, considera di usare una delle sue <a class=\"reference internal\" href=\"#ref-basecommand-subclasses\"><span class=\"std std-ref\">sottoclassi</span></a>.</p>\n<p>Fare una sottoclasse della classe <a class=\"reference internal\" href=\"#django.core.management.BaseCommand\" title=\"django.core.management.BaseCommand\"><code class=\"xref py py-class docutils literal notranslate\">BaseCommand</code></a> ti richiede di implementare il metodo <a class=\"reference internal\" href=\"#django.core.management.BaseCommand.handle\" title=\"django.core.management.BaseCommand.handle\"><code class=\"xref py py-meth docutils literal notranslate\">handle()</code></a>.</p>\n<section id=\"attributes\">\n<h3>Attributi<a class=\"heading-anchor\" href=\"#attributes\"><span class=\"visually-hidden\">Link to this heading</span><span aria-hidden=\"true\">#</span></a></h3>\n<p>Tutti gli attributi possono essere impostati nella tua classe derivata e possono essere usati nelle <a class=\"reference internal\" href=\"#ref-basecommand-subclasses\"><span class=\"std std-ref\">sottoclassi</span></a> di <a class=\"reference internal\" href=\"#django.core.management.BaseCommand\" title=\"django.core.management.BaseCommand\"><code class=\"xref py py-class docutils literal notranslate\">BaseCommand</code></a>.</p>\n<dl class=\"py attribute\">\n<dt class=\"sig sig-object py\" id=\"django.core.management.BaseCommand.help\">\n<span class=\"sig-prename descclassname\">BaseCommand.</span><span class=\"sig-name descname\">help</span><a class=\"heading-anchor\" href=\"#django.core.management.BaseCommand.help\"><span class=\"visually-hidden\">Link to this definition</span><span aria-hidden=\"true\">#</span></a></dt>\n<dd><p>Una breve descrizione del comando, che sarà stampata nel messaggio di aiuto quando l’utente lancia il comando <code class=\"docutils literal notranslate\">python manage.py help &lt;command&gt;</code>.</p>\n</dd></dl>\n\n<dl class=\"py attribute\">\n<dt class=\"sig sig-object py\" id=\"django.core.management.BaseCommand.missing_args_message\">\n<span class=\"sig-prename descclassname\">BaseCommand.</span><span class=\"sig-name descname\">missing_args_message</span><a class=\"heading-anchor\" href=\"#django.core.management.BaseCommand.missing_args_message\"><span class=\"visually-hidden\">Link to this definition</span><span aria-hidden=\"true\">#</span></a></dt>\n<dd><p>Se il tuo comando definisce degli argomenti posizionali obbligatori, puoi personalizzare il messaggio di errore restituito in caso di argomenti mancanti. Quello di default è restituito da <a class=\"reference external\" href=\"https://docs.python.org/3/library/argparse.html#module-argparse\" title=\"(in Python v3.14)\"><code class=\"xref py py-mod docutils literal notranslate\">argparse</code></a> («too few arguments»).</p>\n</dd></dl>\n\n<dl class=\"py attribute\">\n<dt class=\"sig sig-object py\" id=\"django.core.management.BaseCommand.output_transaction\">\n<span class=\"sig-prename descclassname\">BaseCommand.</span><span class=\"sig-name descname\">output_transaction</span><a class=\"heading-anchor\" href=\"#django.core.management.BaseCommand.output_transaction\"><span class=\"visually-hidden\">Link to this definition</span><span aria-hidden=\"true\">#</span></a></dt>\n<dd><p>Un booleano che indica se il comando mostra in output uno statement SQL; se <code class=\"docutils literal notranslate\">True</code>, l’output sarà automaticamente inserito tra <code class=\"docutils literal notranslate\">BEGIN;</code> e <code class=\"docutils literal notranslate\">COMMIT;</code>. Il valore predefinito è <code class=\"docutils literal notranslate\">False</code>.</p>\n</dd></dl>\n\n<dl class=\"py attribute\">\n<dt class=\"sig sig-object py\" id=\"django.core.management.BaseCommand.requires_migrations_checks\">\n<span class=\"sig-prename descclassname\">BaseCommand.</span><span class=\"sig-name descname\">requires_migrations_checks</span><a class=\"heading-anchor\" href=\"#django.core.management.BaseCommand.requires_migrations_checks\"><span class=\"visually-hidden\">Link to this definition</span><span aria-hidden=\"true\">#</span></a></dt>\n<dd><p>Un booleano; se <code class=\"docutils literal notranslate\">True</code>, il comando stampa un messaggio di warning se il set di migrazioni su disco non corrisponde a quelle sul database. Un warning non impedisce l’esecuzione del comando. Il valore predefinito è <code class=\"docutils literal notranslate\">False</code>.</p>\n</dd></dl>\n\n<dl class=\"py attribute\">\n<dt class=\"sig sig-object py\" id=\"django.core.management.BaseCommand.requires_system_checks\">\n<span class=\"sig-prename descclassname\">BaseCommand.</span><span class=\"sig-name descname\">requires_system_checks</span><a class=\"heading-anchor\" href=\"#django.core.management.BaseCommand.requires_system_checks\"><span class=\"visually-hidden\">Link to this definition</span><span aria-hidden=\"true\">#</span></a></dt>\n<dd><p>Un lista di tuple di tag, per esempio <code class=\"docutils literal notranslate\">[Tags.staticfiles, Tags.models]</code>. Il sistema controlla che <span class=\"xref std std-ref\">la registrazione nei tag scelti</span> sia sottoposta a controllo di errori prima di eseguire il comando. Il valore <code class=\"docutils literal notranslate\">'__all__'</code> può essere usato per specificare che tutti i controlli siano eseguiti. Il valore predefinito è <code class=\"docutils literal notranslate\">'__all__'</code>.</p>\n</dd></dl>\n\n<dl class=\"py attribute\">\n<dt class=\"sig sig-object py\" id=\"django.core.management.BaseCommand.style\">\n<span class=\"sig-prename descclassname\">BaseCommand.</span><span class=\"sig-name descname\">style</span><a class=\"heading-anchor\" href=\"#django.core.management.BaseCommand.style\"><span class=\"visually-hidden\">Link to this definition</span><span aria-hidden=\"true\">#</span></a></dt>\n<dd><p>Un attributo di istanza che aiuta a creare output colorato quando si scrive su <code class=\"docutils literal notranslate\">stdout</code> o <code class=\"docutils literal notranslate\">stderr</code>. Per esempio:</p>\n<div class=\"code-block\" data-language=\"default\"><div class=\"code-block-toolbar\"><span class=\"code-block-language\">Code</span><button type=\"button\" class=\"copy-button\" data-copy hidden><span class=\"copy-button-label\">Copy</span></button></div><pre role=\"group\" tabindex=\"0\" aria-label=\"Code code\"><code><span class=\"bp\">self</span><span class=\"o\">.</span>stdout<span class=\"o\">.</span>write<span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"o\">.</span>style<span class=\"o\">.</span>SUCCESS<span class=\"p\">(</span><span class=\"s2\">&quot;...&quot;</span><span class=\"p\">))</span>\n</code></pre></div>\n<p>Vedi <a class=\"reference internal\" href=\"/it/5.1/ref/django-admin/#syntax-coloring\"><span class=\"std std-ref\">Syntax coloring</span></a> per imparare come modificare la palette di colori e visualizzare gli stili disponibili (usa le versioni maiuscole dei «ruoli» descritti in quella sezione).</p>\n<p>Se passi l’opzione <a class=\"reference internal\" href=\"/it/5.1/ref/django-admin/#cmdoption-no-color\"><code class=\"xref std std-option docutils literal notranslate\">--no-color</code></a> quando lanci il comando, tutte le chiamate <code class=\"docutils literal notranslate\">self.style()</code> restituiranno la stringa originale senza colori.</p>\n</dd></dl>\n\n<dl class=\"py attribute\">\n<dt class=\"sig sig-object py\" id=\"django.core.management.BaseCommand.suppressed_base_arguments\">\n<span class=\"sig-prename descclassname\">BaseCommand.</span><span class=\"sig-name descname\">suppressed_base_arguments</span><a class=\"heading-anchor\" href=\"#django.core.management.BaseCommand.suppressed_base_arguments\"><span class=\"visually-hidden\">Link to this definition</span><span aria-hidden=\"true\">#</span></a></dt>\n<dd><p>Le opzioni dei comandi di default da sopprimere nell’output dell’help. Dovrebbe essere un set di nomi di opzione (per es. <code class=\"docutils literal notranslate\">'--verbosity'</code>). I valori di default per tutte le opzioni soppresse vengono comunque passati.</p>\n</dd></dl>\n\n</section>\n<section id=\"methods\">\n<h3>Metodi<a class=\"heading-anchor\" href=\"#methods\"><span class=\"visually-hidden\">Link to this heading</span><span aria-hidden=\"true\">#</span></a></h3>\n<p>La classe <a class=\"reference internal\" href=\"#django.core.management.BaseCommand\" title=\"django.core.management.BaseCommand\"><code class=\"xref py py-class docutils literal notranslate\">BaseCommand</code></a> ha pochi metodi che possono essere sovrascritti ma solo il metodo <a class=\"reference internal\" href=\"#django.core.management.BaseCommand.handle\" title=\"django.core.management.BaseCommand.handle\"><code class=\"xref py py-meth docutils literal notranslate\">handle()</code></a> deve essere implementato.</p>\n<aside class=\"admonition-implementing-a-constructor-in-a-subclass admonition\" role=\"note\">\n<p class=\"admonition-title\">Implementazione di un constructor in una subclasse</p>\n<p>Se implementi <code class=\"docutils literal notranslate\">__init__</code> nella tua sottoclasse di <a class=\"reference internal\" href=\"#django.core.management.BaseCommand\" title=\"django.core.management.BaseCommand\"><code class=\"xref py py-class docutils literal notranslate\">BaseCommand</code></a>, devi chiamare <code class=\"docutils literal notranslate\">__init__</code> di <a class=\"reference internal\" href=\"#django.core.management.BaseCommand\" title=\"django.core.management.BaseCommand\"><code class=\"xref py py-class docutils literal notranslate\">BaseCommand</code></a>:</p>\n<div class=\"code-block\" data-language=\"default\"><div class=\"code-block-toolbar\"><span class=\"code-block-language\">Code</span><button type=\"button\" class=\"copy-button\" data-copy hidden><span class=\"copy-button-label\">Copy</span></button></div><pre role=\"group\" tabindex=\"0\" aria-label=\"Code code\"><code><span class=\"k\">class</span> <span class=\"nc\">Command</span><span class=\"p\">(</span>BaseCommand<span class=\"p\">):</span>\n    <span class=\"k\">def</span> <span class=\"fm\">__init__</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"p\">,</span> <span class=\"o\">*</span>args<span class=\"p\">,</span> <span class=\"o\">**</span>kwargs<span class=\"p\">):</span>\n        <span class=\"nb\">super</span><span class=\"p\">()</span><span class=\"o\">.</span><span class=\"fm\">__init__</span><span class=\"p\">(</span><span class=\"o\">*</span>args<span class=\"p\">,</span> <span class=\"o\">**</span>kwargs<span class=\"p\">)</span>\n        <span class=\"c1\"># ...</span>\n</code></pre></div>\n</aside>\n<dl class=\"py method\">\n<dt class=\"sig sig-object py\" id=\"django.core.management.BaseCommand.create_parser\">\n<span class=\"sig-prename descclassname\">BaseCommand.</span><span class=\"sig-name descname\">create_parser</span><span class=\"sig-paren\">(</span><em class=\"sig-param\">prog_name</em>, <em class=\"sig-param\">subcommand</em>, <em class=\"sig-param\"><span class=\"o\">**</span>kwargs</em><span class=\"sig-paren\">)</span><a class=\"heading-anchor\" href=\"#django.core.management.BaseCommand.create_parser\"><span class=\"visually-hidden\">Link to this definition</span><span aria-hidden=\"true\">#</span></a></dt>\n<dd><p>Restituisce una istanza di <code class=\"docutils literal notranslate\">CommandParser</code>, che è una sottoclasse di <a class=\"reference external\" href=\"https://docs.python.org/3/library/argparse.html#argparse.ArgumentParser\" title=\"(in Python v3.14)\"><code class=\"xref py py-class docutils literal notranslate\">ArgumentParser</code></a> con qualche personalizzazione per Django.</p>\n<p>Puoi personalizzare l’istanza sovrascrivendo questo metodo e chiamando <code class=\"docutils literal notranslate\">super()</code> con parametri <code class=\"docutils literal notranslate\">kwargs</code> <a class=\"reference external\" href=\"https://docs.python.org/3/library/argparse.html#argparse.ArgumentParser\" title=\"(in Python v3.14)\"><code class=\"xref py py-class docutils literal notranslate\">ArgumentParser</code></a>.</p>\n</dd></dl>\n\n<dl class=\"py method\">\n<dt class=\"sig sig-object py\" id=\"django.core.management.BaseCommand.add_arguments\">\n<span class=\"sig-prename descclassname\">BaseCommand.</span><span class=\"sig-name descname\">add_arguments</span><span class=\"sig-paren\">(</span><em class=\"sig-param\">parser</em><span class=\"sig-paren\">)</span><a class=\"heading-anchor\" href=\"#django.core.management.BaseCommand.add_arguments\"><span class=\"visually-hidden\">Link to this definition</span><span aria-hidden=\"true\">#</span></a></dt>\n<dd><p>L’entry point per aggiungere argomenti del parser per gestire gli argomenti della command line passati al comando. I comandi personalizzati dovrebbero sovrascrivere questo metodo per aggiungere sia argomenti facoltativi che posizionali che siano accettati dal comando. Non è necessario chiamare <code class=\"docutils literal notranslate\">super()</code> quando si utilizza una sottoclasse di <code class=\"docutils literal notranslate\">BaseCommand</code>.</p>\n</dd></dl>\n\n<dl class=\"py method\">\n<dt class=\"sig sig-object py\" id=\"django.core.management.BaseCommand.get_version\">\n<span class=\"sig-prename descclassname\">BaseCommand.</span><span class=\"sig-name descname\">get_version</span><span class=\"sig-paren\">(</span><span class=\"sig-paren\">)</span><a class=\"heading-anchor\" href=\"#django.core.management.BaseCommand.get_version\"><span class=\"visually-hidden\">Link to this definition</span><span aria-hidden=\"true\">#</span></a></dt>\n<dd><p>Restituisce la versione di Django, che dovrebbe essere corretta per tutti i comandi Django built-in. I comandi forniti dall’utente possono sovrascrivere questo metodo per restituire la propria versione.</p>\n</dd></dl>\n\n<dl class=\"py method\">\n<dt class=\"sig sig-object py\" id=\"django.core.management.BaseCommand.execute\">\n<span class=\"sig-prename descclassname\">BaseCommand.</span><span class=\"sig-name descname\">execute</span><span class=\"sig-paren\">(</span><em class=\"sig-param\"><span class=\"o\">*</span>args</em>, <em class=\"sig-param\"><span class=\"o\">**</span>options</em><span class=\"sig-paren\">)</span><a class=\"heading-anchor\" href=\"#django.core.management.BaseCommand.execute\"><span class=\"visually-hidden\">Link to this definition</span><span aria-hidden=\"true\">#</span></a></dt>\n<dd><p>Cerca di eseguire questo comando, facendo i controlli di sistema se necessario (come controllato con l’attributo <a class=\"reference internal\" href=\"#django.core.management.BaseCommand.requires_system_checks\" title=\"django.core.management.BaseCommand.requires_system_checks\"><code class=\"xref py py-attr docutils literal notranslate\">requires_system_checks</code></a>). Se il comando solleva <a class=\"reference internal\" href=\"#django.core.management.CommandError\" title=\"django.core.management.CommandError\"><code class=\"xref py py-exc docutils literal notranslate\">CommandError</code></a>, questo viene intercettato e stampato su <code class=\"docutils literal notranslate\">stderr</code>.</p>\n</dd></dl>\n\n<aside class=\"admonition-calling-a-management-command-in-your-code admonition\" role=\"note\">\n<p class=\"admonition-title\">Chiamata di un commando di ?gestione? nel tuo codice</p>\n<p>execute()` non dovrebbe essere chiamato direttamente dal tuo codice per eseguire un comando. Usa invece <a class=\"reference internal\" href=\"/it/5.1/ref/django-admin/#django.core.management.call_command\" title=\"django.core.management.call_command\"><code class=\"xref py py-func docutils literal notranslate\">call_command()</code></a>.</p>\n</aside>\n<dl class=\"py method\">\n<dt class=\"sig sig-object py\" id=\"django.core.management.BaseCommand.handle\">\n<span class=\"sig-prename descclassname\">BaseCommand.</span><span class=\"sig-name descname\">handle</span><span class=\"sig-paren\">(</span><em class=\"sig-param\"><span class=\"o\">*</span>args</em>, <em class=\"sig-param\"><span class=\"o\">**</span>options</em><span class=\"sig-paren\">)</span><a class=\"heading-anchor\" href=\"#django.core.management.BaseCommand.handle\"><span class=\"visually-hidden\">Link to this definition</span><span aria-hidden=\"true\">#</span></a></dt>\n<dd><p>La logica attuale del comando. Le sottoclassi devono implementare questo metodo</p>\n<p>Può restituire una stringa che sarà stampata su <code class=\"docutils literal notranslate\">stdout</code> (tra <code class=\"docutils literal notranslate\">BEGIN;</code> e <code class=\"docutils literal notranslate\">COMMIT;</code> se <a class=\"reference internal\" href=\"#django.core.management.BaseCommand.output_transaction\" title=\"django.core.management.BaseCommand.output_transaction\"><code class=\"xref py py-attr docutils literal notranslate\">output_transaction</code></a> è <code class=\"docutils literal notranslate\">True</code>).</p>\n</dd></dl>\n\n<dl class=\"py method\">\n<dt class=\"sig sig-object py\" id=\"django.core.management.BaseCommand.check\">\n<span class=\"sig-prename descclassname\">BaseCommand.</span><span class=\"sig-name descname\">check</span><span class=\"sig-paren\">(</span><em class=\"sig-param\">app_configs<span class=\"o\">=</span><span class=\"default_value\">None</span></em>, <em class=\"sig-param\">tags<span class=\"o\">=</span><span class=\"default_value\">None</span></em>, <em class=\"sig-param\">display_num_errors<span class=\"o\">=</span><span class=\"default_value\">False</span></em>, <em class=\"sig-param\">include_deployment_checks<span class=\"o\">=</span><span class=\"default_value\">False</span></em>, <em class=\"sig-param\">fail_level<span class=\"o\">=</span><span class=\"default_value\">checks.ERROR</span></em>, <em class=\"sig-param\">databases<span class=\"o\">=</span><span class=\"default_value\">None</span></em><span class=\"sig-paren\">)</span><a class=\"heading-anchor\" href=\"#django.core.management.BaseCommand.check\"><span class=\"visually-hidden\">Link to this definition</span><span aria-hidden=\"true\">#</span></a></dt>\n<dd><p>Usa il framework di controlli di sistema per ispezionare l’intero progetto Django in cerca di potenziali problemi. I problemi gravi sono segnalati cpme <a class=\"reference internal\" href=\"#django.core.management.CommandError\" title=\"django.core.management.CommandError\"><code class=\"xref py py-exc docutils literal notranslate\">CommandError</code></a>; i warning sono stampati su <code class=\"docutils literal notranslate\">stderr</code>; le notifiche minori sono stampate su <code class=\"docutils literal notranslate\">stdout</code>.</p>\n<p>If <code class=\"docutils literal notranslate\">app_configs</code> and <code class=\"docutils literal notranslate\">tags</code> are both <code class=\"docutils literal notranslate\">None</code>, all system checks are\nperformed except deployment and database related checks. <code class=\"docutils literal notranslate\">tags</code> can be a\nlist of check tags, like <code class=\"docutils literal notranslate\">compatibility</code> or <code class=\"docutils literal notranslate\">models</code>.</p>\n<p>You can pass <code class=\"docutils literal notranslate\">include_deployment_checks=True</code> to also perform deployment\nchecks, and list of database aliases in the <code class=\"docutils literal notranslate\">databases</code> to run database\nrelated checks against them.</p>\n</dd></dl>\n\n</section>\n<section id=\"basecommand-subclasses\">\n<span id=\"ref-basecommand-subclasses\"></span><h3>sottoclassi <code class=\"docutils literal notranslate\">BaseCommand</code><a class=\"heading-anchor\" href=\"#basecommand-subclasses\"><span class=\"visually-hidden\">Link to this heading</span><span aria-hidden=\"true\">#</span></a></h3>\n<dl class=\"py class\">\n<dt class=\"sig sig-object py\" id=\"django.core.management.AppCommand\">\n<em class=\"property\"><span class=\"k\">class</span> </em><span class=\"sig-name descname\">AppCommand</span><a class=\"heading-anchor\" href=\"#django.core.management.AppCommand\"><span class=\"visually-hidden\">Link to this definition</span><span aria-hidden=\"true\">#</span></a></dt>\n<dd></dd></dl>\n\n<p>Un comando di gestione che accetta una o più etichette di applicazioni installate come argomenti e fa qualcosa con ciascuna di esse.</p>\n<p>Piuttosto che implementare <a class=\"reference internal\" href=\"#django.core.management.BaseCommand.handle\" title=\"django.core.management.BaseCommand.handle\"><code class=\"xref py py-meth docutils literal notranslate\">handle()</code></a>, le sottoclassi devono implementare <a class=\"reference internal\" href=\"#django.core.management.AppCommand.handle_app_config\" title=\"django.core.management.AppCommand.handle_app_config\"><code class=\"xref py py-meth docutils literal notranslate\">handle_app_config()</code></a>, che sarà chiamata una volta per ogni applicazione.</p>\n<dl class=\"py method\">\n<dt class=\"sig sig-object py\" id=\"django.core.management.AppCommand.handle_app_config\">\n<span class=\"sig-prename descclassname\">AppCommand.</span><span class=\"sig-name descname\">handle_app_config</span><span class=\"sig-paren\">(</span><em class=\"sig-param\">app_config</em>, <em class=\"sig-param\"><span class=\"o\">**</span>options</em><span class=\"sig-paren\">)</span><a class=\"heading-anchor\" href=\"#django.core.management.AppCommand.handle_app_config\"><span class=\"visually-hidden\">Link to this definition</span><span aria-hidden=\"true\">#</span></a></dt>\n<dd><p>Effettua le azioni del comando per <code class=\"docutils literal notranslate\">app_config</code>, che sarà una istanza di <a class=\"reference internal\" href=\"/it/5.1/ref/applications/#django.apps.AppConfig\" title=\"django.apps.AppConfig\"><code class=\"xref py py-class docutils literal notranslate\">AppConfig</code></a> corrispondente ad una etichetta di applicazione fornita sulla linea di comando.</p>\n</dd></dl>\n\n<dl class=\"py class\">\n<dt class=\"sig sig-object py\" id=\"django.core.management.LabelCommand\">\n<em class=\"property\"><span class=\"k\">class</span> </em><span class=\"sig-name descname\">LabelCommand</span><a class=\"heading-anchor\" href=\"#django.core.management.LabelCommand\"><span class=\"visually-hidden\">Link to this definition</span><span aria-hidden=\"true\">#</span></a></dt>\n<dd></dd></dl>\n\n<p>Un comando di gestione che accetta uno o più argomenti arbitrari (etichette) dalla linea di comando e fa qualcosa con ciascuno di essi.</p>\n<p>Piuttosto che implementare <a class=\"reference internal\" href=\"#django.core.management.BaseCommand.handle\" title=\"django.core.management.BaseCommand.handle\"><code class=\"xref py py-meth docutils literal notranslate\">handle()</code></a>, le sottoclassi devono implmentare <a class=\"reference internal\" href=\"#django.core.management.LabelCommand.handle_label\" title=\"django.core.management.LabelCommand.handle_label\"><code class=\"xref py py-meth docutils literal notranslate\">handle_label()</code></a>, che sarà chiamato una volta per ogni etichetta.</p>\n<dl class=\"py attribute\">\n<dt class=\"sig sig-object py\" id=\"django.core.management.LabelCommand.label\">\n<span class=\"sig-prename descclassname\">LabelCommand.</span><span class=\"sig-name descname\">label</span><a class=\"heading-anchor\" href=\"#django.core.management.LabelCommand.label\"><span class=\"visually-hidden\">Link to this definition</span><span aria-hidden=\"true\">#</span></a></dt>\n<dd><p>Una stringa che descrive gli argomenti arbitrari forniti al comando. La stringa viene usata nel testo di utilizzo e nei messaggi di errore del comando. Di default è pari a <code class=\"docutils literal notranslate\">'label'</code>.</p>\n</dd></dl>\n\n<dl class=\"py method\">\n<dt class=\"sig sig-object py\" id=\"django.core.management.LabelCommand.handle_label\">\n<span class=\"sig-prename descclassname\">LabelCommand.</span><span class=\"sig-name descname\">handle_label</span><span class=\"sig-paren\">(</span><em class=\"sig-param\">label</em>, <em class=\"sig-param\"><span class=\"o\">**</span>options</em><span class=\"sig-paren\">)</span><a class=\"heading-anchor\" href=\"#django.core.management.LabelCommand.handle_label\"><span class=\"visually-hidden\">Link to this definition</span><span aria-hidden=\"true\">#</span></a></dt>\n<dd><p>Effettua le azioni del comando per <code class=\"docutils literal notranslate\">label</code>, che sarà la stringa come è fornita dalla riga di comando.</p>\n</dd></dl>\n\n</section>\n<section id=\"command-exceptions\">\n<h3>Eccezioni di comando<a class=\"heading-anchor\" href=\"#command-exceptions\"><span class=\"visually-hidden\">Link to this heading</span><span aria-hidden=\"true\">#</span></a></h3>\n<dl class=\"py exception\">\n<dt class=\"sig sig-object py\" id=\"django.core.management.CommandError\">\n<em class=\"property\"><span class=\"k\">exception</span> </em><span class=\"sig-name descname\">CommandError</span><span class=\"sig-paren\">(</span><em class=\"sig-param\">returncode<span class=\"o\">=</span><span class=\"default_value\">1</span></em><span class=\"sig-paren\">)</span><a class=\"heading-anchor\" href=\"#django.core.management.CommandError\"><span class=\"visually-hidden\">Link to this definition</span><span aria-hidden=\"true\">#</span></a></dt>\n<dd></dd></dl>\n\n<p>Una classe di eccezione che indica un problema mentre si esegue un comando di gestione.</p>\n<p>Se questa eccezione viene sollevata durante l’esecuzione di un comando di management da una console a linea di comando, sarà gestito e trasformato in un messaggio di errore stampato in modo gradevole verso lo stream di output appropriato (per es. <code class=\"docutils literal notranslate\">stderr</code>); di conseguenza, sollevare questa eccezione (con una descrizione sensibile dell’errore) è la modalità preferita di indicare che qualcosa è andato storto durante l’esecuzione di un comando. Essa accetta l’argomento opzionale <code class=\"docutils literal notranslate\">returncode</code> per personalizzare l’exit status del comando di management, usando <a class=\"reference external\" href=\"https://docs.python.org/3/library/sys.html#sys.exit\" title=\"(in Python v3.14)\"><code class=\"xref py py-func docutils literal notranslate\">sys.exit()</code></a>.</p>\n<p>Se il comando di gestione è chiamato dal codice con <a class=\"reference internal\" href=\"/it/5.1/ref/django-admin/#django.core.management.call_command\" title=\"django.core.management.call_command\"><code class=\"xref py py-func docutils literal notranslate\">call_command()</code></a>, è tuo compito catturare l’eccezione quando è necessario.</p>\n</section>\n</section>","rootId":"module-django.core.management","toc":[{"title":"Accetta argomenti opzionali","anchor":"accepting-optional-arguments","children":[]},{"title":"Commandi di gestione e traduzioni/locale","anchor":"management-commands-and-locales","children":[]},{"title":"Testing","anchor":"testing","children":[]},{"title":"Override dei comandi","anchor":"overriding-commands","children":[]},{"title":"Oggetti Command","anchor":"command-objects","children":[{"title":"Attributi","anchor":"attributes","children":[]},{"title":"Metodi","anchor":"methods","children":[]},{"title":"sottoclassi BaseCommand","anchor":"basecommand-subclasses","children":[]},{"title":"Eccezioni di comando","anchor":"command-exceptions","children":[]}]}],"breadcrumbs":[{"docname":"howto/index","title":"How-to guides","url":"/it/5.1/howto/"}],"prev":{"docname":"howto/csrf","title":"Come usare la protezione CSRF di Django","url":"/it/5.1/howto/csrf/"},"next":{"docname":"howto/custom-file-storage","title":"Come scrivere una storage class personalizzata","url":"/it/5.1/howto/custom-file-storage/"},"formats":{"html":"/it/5.1/howto/custom-management-commands/","markdown":"/it/5.1/howto/custom-management-commands.md","json":"/it/5.1/howto/custom-management-commands.json"},"source":"https://github.com/django/django/blob/stable/5.1.x/docs/howto/custom-management-commands.txt","official":"https://docs.djangoproject.com/it/5.1/howto/custom-management-commands/","inVersions":["6.1","6.0","5.2","5.1","5.0","4.2","4.1","4.0","3.2"],"inLocales":["en","zh-hans","fr","ja","id","it","pt-br","ko","es","el","pl"]}