{"title":"How to create custom django-admin commands","version":"4.0","locale":"pt-br","docname":"howto/custom-management-commands","url":"/pt-br/4.0/howto/custom-management-commands/","canonical":"https://djangodocs.dev/pt-br/4.0/howto/custom-management-commands/","summary":"As aplicações podem registrar suas próprias ações com manage.py. Por exemplo, você pode querer adicionar uma ação manage.py para uma aplicação Django que…","html":"<span id=\"how-to-create-custom-django-admin-commands\"></span><h1>How to create custom <code class=\"docutils literal notranslate\">django-admin</code> commands<a class=\"heading-anchor\" href=\"#module-django.core.management\"><span class=\"visually-hidden\">Link para este cabeçalho</span><span aria-hidden=\"true\">#</span></a></h1>\n<p>As aplicações podem registrar suas próprias ações com <code class=\"docutils literal notranslate\">manage.py</code>. Por exemplo, você pode querer adicionar uma ação <code class=\"docutils literal notranslate\">manage.py</code> para uma aplicação Django que você está distribuindo. Neste documento, construiremos um comando customizado <code class=\"docutils literal notranslate\">closepoll</code> para a aplicação <code class=\"docutils literal notranslate\">polls</code> do <a class=\"reference internal\" href=\"/pt-br/4.0/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=\"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>polls<span class=\"o\">/</span>\n    <span class=\"fm\">__init__</span><span class=\"o\">.</span>py\n    models<span class=\"o\">.</span>py\n    management<span class=\"o\">/</span>\n        <span class=\"fm\">__init__</span><span class=\"o\">.</span>py\n        commands<span class=\"o\">/</span>\n            <span class=\"fm\">__init__</span><span class=\"o\">.</span>py\n            _private<span class=\"o\">.</span>py\n            closepoll<span class=\"o\">.</span>py\n    tests<span class=\"o\">.</span>py\n    views<span class=\"o\">.</span>py\n</code></pre></div>\n<p>Neste exemplo, o comando <code class=\"docutils literal notranslate\">closepoll</code> estará disponível a qualquer projeto que inclua a aplicação <code class=\"docutils literal notranslate\">polls</code> em <a class=\"reference internal\" href=\"/pt-br/4.0/ref/settings/#std-setting-INSTALLED_APPS\"><code class=\"xref std std-setting docutils literal notranslate\">INSTALLED_APPS</code></a>.</p>\n<p>O módulo <code class=\"docutils literal notranslate\">_private.py</code> não estará disponível como um comando de gerenciamento.</p>\n<p>O módulo <code class=\"docutils literal notranslate\">closepoll.py</code> tem apenas uma exigência – deve definir uma classe <code class=\"docutils literal notranslate\">Command</code> que estende <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> ou uma de suas <span class=\"xref std std-ref\">subclasses</span>.</p>\n<aside class=\"admonition-standalone-scripts admonition\" role=\"note\">\n<p class=\"admonition-title\">Scripts autônomos</p>\n<p>Comandos de gerenciamento customizados, são especialmente úteis para a execução de scripts independentes ou para scripts que são periodicamente executados a partir do crontab do UNIX ou do painel de controle de tarefas agendadas do Windows.</p>\n</aside>\n<p>Para implementar o comando, edite <code class=\"docutils literal notranslate\">polls/management/commands/closepoll.py</code> para que fique assim:</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<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=\"s1\">&#39;Closes the specified poll for voting&#39;</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=\"s1\">&#39;poll_ids&#39;</span><span class=\"p\">,</span> nargs<span class=\"o\">=</span><span class=\"s1\">&#39;+&#39;</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=\"s1\">&#39;poll_ids&#39;</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><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</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 estiver usando comandos de gerenciamento e desejar enviar a saída para console, deve se escrever para o <code class=\"docutils literal notranslate\">self.stdout</code> e <code class=\"docutils literal notranslate\">self.stderr</code>, ao invés de imprimir para o <code class=\"docutils literal notranslate\">stdout</code> e <code class=\"docutils literal notranslate\">stderr</code> diretamente. Ao usar esses proxies, torna-se muito mais fácil para testar o seu comando personalizado. Observe também que você não precisa terminar mensagens com um caractere de nova linha, este será adicionado automaticamente, a menos que você especifique o parâmetro <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=\"s1\">&#39;&#39;</span><span class=\"p\">)</span>\n</code></pre></div>\n</aside>\n<p>O novo comando personalizado pode ser chamado usando <code class=\"docutils literal notranslate\">python manage.py closepoll &lt;poll_ids&gt;</code>.</p>\n<p>O método <code class=\"docutils literal notranslate\">handle()</code> usa um ou mais <code class=\"docutils literal notranslate\">poll_ids</code> e altera o “poll.opened” para <code class=\"docutils literal notranslate\">False</code> para cada um. Se o usuário referenciar qualquer enquete inexistente, uma exceção será levantada <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>. O atributo <code class=\"docutils literal notranslate\">poll.opened</code> não existe no <a class=\"reference internal\" href=\"/pt-br/4.0/intro/tutorial02/\"><span class=\"doc\">tutorial</span></a> e foi adicionado em <code class=\"docutils literal notranslate\">polls.models.Question</code> para este exemplo.</p>\n<section id=\"accepting-optional-arguments\">\n<span id=\"custom-commands-options\"></span><h2>Aceitando argumentos opcionais<a class=\"heading-anchor\" href=\"#accepting-optional-arguments\"><span class=\"visually-hidden\">Link para este cabeçalho</span><span aria-hidden=\"true\">#</span></a></h2>\n<p>O mesmo <code class=\"docutils literal notranslate\">closepoll</code> poderia ser facilmente modificado para excluir uma determinada enquete, ao invés de fechá-la, aceitando as opções de linha de comando adicionais. Estas opções personalizadas podem ser adicionadas no método <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> assim:</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=\"s1\">&#39;poll_ids&#39;</span><span class=\"p\">,</span> nargs<span class=\"o\">=</span><span class=\"s1\">&#39;+&#39;</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=\"s1\">&#39;--delete&#39;</span><span class=\"p\">,</span>\n            action<span class=\"o\">=</span><span class=\"s1\">&#39;store_true&#39;</span><span class=\"p\">,</span>\n            help<span class=\"o\">=</span><span class=\"s1\">&#39;Delete poll instead of closing it&#39;</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=\"s1\">&#39;delete&#39;</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>A opção (<code class=\"docutils literal notranslate\">delete</code> no nosso exemplo) está disponível no parâmetro dict (options) do método handle. Veja  <a class=\"reference external\" href=\"https://docs.python.org/3/library/argparse.html#module-argparse\" title=\"(em Python v3.14)\"><code class=\"xref py py-mod docutils literal notranslate\">argparse</code></a> na documentação do Python para saber mais sobre o uso do <code class=\"docutils literal notranslate\">add_argument</code>.</p>\n<p>Além de ser capaz de adicionar opções personalizadas de linha de comando, todos <a class=\"reference internal\" href=\"/pt-br/4.0/ref/django-admin/\"><span class=\"doc\">comandos de gereciamento</span></a>  aceitam algumas opções padrão, tais como <a href=\"#id1\"><span class=\"problematic\" id=\"id2\">:opção:`--verbosity`</span></a> e <a href=\"#id3\"><span class=\"problematic\" id=\"id4\">:opção:`--traceback`</span></a>.</p>\n</section>\n<section id=\"management-commands-and-locales\">\n<span id=\"id1\"></span><h2>Comandos de gerenciamento e localidades<a class=\"heading-anchor\" href=\"#management-commands-and-locales\"><span class=\"visually-hidden\">Link para este cabeçalho</span><span aria-hidden=\"true\">#</span></a></h2>\n<p>Por padrão, comandos de gerenciamento são executados com a localidade corrente ativa.</p>\n<p>Se, por alguma razão, seu comando de gerenciamento personalizado precise ser executado sem um local ativo (por exemplo, para evitar que o conteúdo traduzido seja inserido dentro do banco de dados), desative a tradução utilizado o decorator <code class=\"docutils literal notranslate\">&#64;no_translations</code> no seu método <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<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>\n        <span class=\"o\">...</span>\n</code></pre></div>\n<p>Como a desativação da tradução requer acesso as configurações definidas, os decorator’s não podem ser utilizados por comandos que trabalham sem configurações pré definidas.</p>\n</section>\n<section id=\"testing\">\n<h2>Testando<a class=\"heading-anchor\" href=\"#testing\"><span class=\"visually-hidden\">Link para este cabeçalho</span><span aria-hidden=\"true\">#</span></a></h2>\n<p>Informações sobre como testar comandos de gerenciamento personalizados pode ser encontradas na <a class=\"reference internal\" href=\"/pt-br/4.0/topics/testing/tools/#topics-testing-management-commands\"><span class=\"std std-ref\">documentação de teste</span></a>.</p>\n</section>\n<section id=\"overriding-commands\">\n<h2>Sobrescrevendo comandos.<a class=\"heading-anchor\" href=\"#overriding-commands\"><span class=\"visually-hidden\">Link para este cabeçalho</span><span aria-hidden=\"true\">#</span></a></h2>\n<p>Django registra os comandos internos e depois procura os comandos em <a class=\"reference internal\" href=\"/pt-br/4.0/ref/settings/#std-setting-INSTALLED_APPS\"><code class=\"xref std std-setting docutils literal notranslate\">INSTALLED_APPS</code></a> em orderm reversa. Durante a busca, se um comando duplica um comando já registrado, o novo comando encontrado substitui o primeiro.</p>\n<p>Em outras palavras, para sobrescrever um comando, o novo comando precisa ter o mesmo nome e seu app precisa estar antes do comando da app a ser sobrescrito em : setting:INSTALLED_APPS.</p>\n<p>Comandos de gerenciamento de aplicações de terceiros que foram sobrescritos de maneira nao intencional podem se tornar disponíveis sob um novo nome através da criação de um novo comando em um dos apps do projeto (colocado antes da aplicação de terceiros em :setting:<a href=\"#id1\"><span class=\"problematic\" id=\"id2\">`</span></a>INSTALLED_APPS) o qual importa o ‘Comando’ do comando sobrescrito.</p>\n</section>\n<section id=\"command-objects\">\n<h2>Objetos Command<a class=\"heading-anchor\" href=\"#command-objects\"><span class=\"visually-hidden\">Link para este cabeçalho</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 para esta definição</span><span aria-hidden=\"true\">#</span></a></dt>\n<dd></dd></dl>\n\n<p>A classe base a partir da qual todos os comandos de gestão, em última análise derivam.</p>\n<p>Use esta classe se você quer acesso a todos os mecanismos que realizam o parse dos argumentos da linha de comando e verificar qual código chamar em resposta; se você não precisa mudar este comportamento, considere usar uma dessas <a class=\"reference internal\" href=\"#ref-basecommand-subclasses\"><span class=\"std std-ref\">subclasses</span></a>.</p>\n<p>Subclasssing a 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> requer que você implemente o método <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>Atributos<a class=\"heading-anchor\" href=\"#attributes\"><span class=\"visually-hidden\">Link para este cabeçalho</span><span aria-hidden=\"true\">#</span></a></h3>\n<p>Todos os atributos podem ser definidos em sua classe derivada e podem ser usados nas <a class=\"reference internal\" href=\"#ref-basecommand-subclasses\"><span class=\"std std-ref\">subclasses</span></a> de <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 para esta definição</span><span aria-hidden=\"true\">#</span></a></dt>\n<dd><p>Uma breve descrição do comando, que será impresso na mensagem de ajuda quando o usuário executar o 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 para esta definição</span><span aria-hidden=\"true\">#</span></a></dt>\n<dd><p>Se o seu comando define argumentos posicionais obrigatórios, você pode personalizar a mensagem de erro devolvida em caso de falta de argumentos. O padrão é a saída por <a class=\"reference external\" href=\"https://docs.python.org/3/library/argparse.html#module-argparse\" title=\"(em Python v3.14)\"><code class=\"xref py py-mod docutils literal notranslate\">argparse</code></a> (“poucos argumentos”).</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 para esta definição</span><span aria-hidden=\"true\">#</span></a></dt>\n<dd><p>Um booleano que indica como os comandos retornam SQL “statements”; Se <code class=\"docutils literal notranslate\">True</code>, a saída será automaticamente envolvido com <code class=\"docutils literal notranslate\">BEGIN;</code> e <code class=\"docutils literal notranslate\">COMMIT;</code>. O valor padrão é <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 para esta definição</span><span aria-hidden=\"true\">#</span></a></dt>\n<dd><p>Um booleano; Se <code class=\"docutils literal notranslate\">True</code>, o comando “printa” um alerta se o conjunto de migrações no disco não estiver de acordo com as migrações no banco de dados. Um alerta não previne o comando de ser executado. O valor padrão é <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 para esta definição</span><span aria-hidden=\"true\">#</span></a></dt>\n<dd><p>A list or tuple of tags, e.g. <code class=\"docutils literal notranslate\">[Tags.staticfiles, Tags.models]</code>. System\nchecks <a class=\"reference internal\" href=\"/pt-br/4.0/topics/checks/#registering-labeling-checks\"><span class=\"std std-ref\">registered in the chosen tags</span></a>\nwill be checked for errors prior to executing the command. The value\n<code class=\"docutils literal notranslate\">'__all__'</code> can be used to specify that all system checks should be\nperformed. Default value is <code class=\"docutils literal notranslate\">'__all__'</code>.</p>\n<aside class=\"version-note version-changed\" data-version=\"3.2\" role=\"note\">\n<p class=\"version-note-title\">Changed in Django 3.2</p><p>In older versions, the <code class=\"docutils literal notranslate\">requires_system_checks</code> attribute expects a\nboolean value instead of a list or tuple of tags.</p>\n</aside>\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 para esta definição</span><span aria-hidden=\"true\">#</span></a></dt>\n<dd><p>Um atributo de instância que ajuda a criar uma saída colorida quando se escreve no <code class=\"docutils literal notranslate\">stdout</code> ou <code class=\"docutils literal notranslate\">stderr</code>. Por exemplo:</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=\"s1\">&#39;...&#39;</span><span class=\"p\">))</span>\n</code></pre></div>\n<p>Veja <span class=\"xref std std-ref\">sintaxe-coloring</span> para aprender como modificar a paleta de cores e ver os estilos disponíveis (use caixa-alta das versões das opções descritas nessa seção).</p>\n<p>Se você passar a opção <a class=\"reference internal\" href=\"/pt-br/4.0/ref/django-admin/#cmdoption-no-color\"><code class=\"xref std std-option docutils literal notranslate\">--no-color</code></a> ao executar o seu comando, todas as chamadas <code class=\"docutils literal notranslate\">self.style()</code> retornarão a string original sem colorir.</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 para esta definição</span><span aria-hidden=\"true\">#</span></a></dt>\n<dd><aside class=\"version-note version-added\" data-version=\"4.0\" role=\"note\">\n<p class=\"version-note-title\">New in Django 4.0</p></aside>\n<p>The default command options to suppress in the help output. This should be\na set of option names (e.g. <code class=\"docutils literal notranslate\">'--verbosity'</code>). The default values for the\nsuppressed options are still passed.</p>\n</dd></dl>\n\n</section>\n<section id=\"methods\">\n<h3>Métodos<a class=\"heading-anchor\" href=\"#methods\"><span class=\"visually-hidden\">Link para este cabeçalho</span><span aria-hidden=\"true\">#</span></a></h3>\n<p><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> tem alguns métodos que podem ser sobrescritos mas apenas o método <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 ser implementado.</p>\n<aside class=\"admonition-implementing-a-constructor-in-a-subclass admonition\" role=\"note\">\n<p class=\"admonition-title\">Implementando um construtor em uma subclasse</p>\n<p>Se você implementar <code class=\"docutils literal notranslate\">__init__</code> em sua subclasse de <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>, você deve chamar: o <code class=\"docutils literal notranslate\">__init__</code> do class:` BaseCommand`:</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 para esta definição</span><span aria-hidden=\"true\">#</span></a></dt>\n<dd><p>Retorna uma instância de <code class=\"docutils literal notranslate\">CommandParser</code>, o qual é uma classe: argparse.ArgumentParser subclasse, com algumas personalizações para o Django.</p>\n<p>Você pode customizar a instância por sobrecarga desse método, chamando <code class=\"docutils literal notranslate\">super()</code> com <code class=\"docutils literal notranslate\">kwargs</code> da classe:~argparse.ArgumentParser como parâmetro.</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 para esta definição</span><span aria-hidden=\"true\">#</span></a></dt>\n<dd><p>Ponto de entrada para passar um “parser” como argumento para lidar com os argumentos da linha de comando passados ao comando. Comandos personalizados devem sobrescrever este método para adicionar ambos argumentos posicionais e opicionais aceitos pelo comando. Não é necessário chamar o <code class=\"docutils literal notranslate\">super()</code> quando for uma subclasse de  <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 para esta definição</span><span aria-hidden=\"true\">#</span></a></dt>\n<dd><p>Retorna a versão do Django, que deve ser a correta para todos os comandos internos do Django. É possível sobrescrever este método para que comandos fornecidos pelo usuário possam  retornar a sua própria versão.</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 para esta definição</span><span aria-hidden=\"true\">#</span></a></dt>\n<dd><p>Tries to execute this command, performing system checks if needed (as\ncontrolled by the <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> attribute). If the command\nraises a <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>, it’s intercepted and printed to <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\">Chamando um comando de gestão dentro do seu código</p>\n<p><code class=\"docutils literal notranslate\">execute()</code> não deve ser chamado diretamente do seu código para executar um comando. Ao invés disso, use <a class=\"reference internal\" href=\"/pt-br/4.0/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 para esta definição</span><span aria-hidden=\"true\">#</span></a></dt>\n<dd><p>A lógica atual do comando. Subclasses devem implementar este método.</p>\n<p>Pode retornar uma string tal qual será impressa no “stdout” (acrescido por “BEGIN;” e “COMMIT;” se :attr:’output_transaction’ for “True”).</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><span class=\"sig-paren\">)</span><a class=\"heading-anchor\" href=\"#django.core.management.BaseCommand.check\"><span class=\"visually-hidden\">Link para esta definição</span><span aria-hidden=\"true\">#</span></a></dt>\n<dd><p>Uses the system check framework to inspect the entire Django project for\npotential problems. Serious problems are raised as a <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>;\nwarnings are output to <code class=\"docutils literal notranslate\">stderr</code>; minor notifications are output to\n<code class=\"docutils literal notranslate\">stdout</code>.</p>\n<p>Se  ambos <code class=\"docutils literal notranslate\">app_configs</code> e  <code class=\"docutils literal notranslate\">tags</code> forem  <code class=\"docutils literal notranslate\">None</code>, todas as verificações do sistema são realizadas. `` Tags`` pode ser uma lista tags de checagem, como <code class=\"docutils literal notranslate\">compatibility</code> ou <code class=\"docutils literal notranslate\">models</code>.</p>\n</dd></dl>\n\n</section>\n<section id=\"basecommand-subclasses\">\n<span id=\"ref-basecommand-subclasses\"></span><h3>Subclasses de <code class=\"docutils literal notranslate\">BaseCommand</code><a class=\"heading-anchor\" href=\"#basecommand-subclasses\"><span class=\"visually-hidden\">Link para este cabeçalho</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 para esta definição</span><span aria-hidden=\"true\">#</span></a></dt>\n<dd></dd></dl>\n\n<p>Um comando de gerenciamento que recebe como argumento um ou mais “labels” de aplicação instaladas, e faz alguma coisa com cada um deles.</p>\n<p>Melhor que implementar <code class=\"xref py py-meth docutils literal notranslate\">handle()</code>, as subclasses devem implementar :meth:` ~AppCommand.handle_app_config`, o qual será chamado uma vez para cada aplicação.</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 para esta definição</span><span aria-hidden=\"true\">#</span></a></dt>\n<dd><p>Executar ações do comando para <code class=\"docutils literal notranslate\">app_config</code>, o qual será uma instância de <a class=\"reference internal\" href=\"/pt-br/4.0/ref/applications/#django.apps.AppConfig\" title=\"django.apps.AppConfig\"><code class=\"xref py py-class docutils literal notranslate\">AppConfig</code></a> correspondente a um label do aplicativo informado na linha de 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 para esta definição</span><span aria-hidden=\"true\">#</span></a></dt>\n<dd></dd></dl>\n\n<p>Um comando de gestão que recebe um ou mais argumentos arbitrários (“labels”) na linha de comando, e faz alguma coisa com cada um deles.</p>\n<p>Em vez de implementar <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>, subclasses devem implementar <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>, que será chamado uma vez para cada etiqueta.</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 para esta definição</span><span aria-hidden=\"true\">#</span></a></dt>\n<dd><p>Uma string que descreve os argumentos arbitrários passados para o comando. A string é usada no texto de uso e mensagens de erro do comando. Padrão para `` ‘label’<a href=\"#id1\"><span class=\"problematic\" id=\"id2\">``</span></a>.</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 para esta definição</span><span aria-hidden=\"true\">#</span></a></dt>\n<dd><p>Executar ações do comando para <code class=\"docutils literal notranslate\">label</code>, que será a string como  informada na linha de comando.</p>\n</dd></dl>\n\n</section>\n<section id=\"command-exceptions\">\n<h3>Exceções de comando<a class=\"heading-anchor\" href=\"#command-exceptions\"><span class=\"visually-hidden\">Link para este cabeçalho</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 para esta definição</span><span aria-hidden=\"true\">#</span></a></dt>\n<dd></dd></dl>\n\n<p>A classe de exceção indica um problema ao executar um comando de gestão.</p>\n<p>If this exception is raised during the execution of a management command from a\ncommand line console, it will be caught and turned into a nicely-printed error\nmessage to the appropriate output stream (i.e., <code class=\"docutils literal notranslate\">stderr</code>); as a result,\nraising this exception (with a sensible description of the error) is the\npreferred way to indicate that something has gone wrong in the execution of a\ncommand. It accepts the optional <code class=\"docutils literal notranslate\">returncode</code> argument to customize the exit\nstatus for the management command to exit with, using <a class=\"reference external\" href=\"https://docs.python.org/3/library/sys.html#sys.exit\" title=\"(em Python v3.14)\"><code class=\"xref py py-func docutils literal notranslate\">sys.exit()</code></a>.</p>\n<p>Se um comando de gestão é chamado do código através do <a class=\"reference internal\" href=\"/pt-br/4.0/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>, cabe a você capturar a exceção quando necessário.</p>\n</section>\n</section>","rootId":"module-django.core.management","toc":[{"title":"Aceitando argumentos opcionais","anchor":"accepting-optional-arguments","children":[]},{"title":"Comandos de gerenciamento e localidades","anchor":"management-commands-and-locales","children":[]},{"title":"Testando","anchor":"testing","children":[]},{"title":"Sobrescrevendo comandos.","anchor":"overriding-commands","children":[]},{"title":"Objetos Command","anchor":"command-objects","children":[{"title":"Atributos","anchor":"attributes","children":[]},{"title":"Métodos","anchor":"methods","children":[]},{"title":"Subclasses de BaseCommand","anchor":"basecommand-subclasses","children":[]},{"title":"Exceções de comando","anchor":"command-exceptions","children":[]}]}],"breadcrumbs":[{"docname":"howto/index","title":"Guias de “como fazer”","url":"/pt-br/4.0/howto/"}],"prev":{"docname":"howto/auth-remote-user","title":"How to authenticate using REMOTE_USER","url":"/pt-br/4.0/howto/auth-remote-user/"},"next":{"docname":"howto/custom-model-fields","title":"How to create custom model fields","url":"/pt-br/4.0/howto/custom-model-fields/"},"formats":{"html":"/pt-br/4.0/howto/custom-management-commands/","markdown":"/pt-br/4.0/howto/custom-management-commands.md","json":"/pt-br/4.0/howto/custom-management-commands.json"},"source":"https://github.com/django/django/blob/stable/4.0.x/docs/howto/custom-management-commands.txt","official":"https://docs.djangoproject.com/pt-br/4.0/howto/custom-management-commands/","inVersions":["6.1","6.0","5.2","5.1","5.0","4.2","4.1","4.0","3.2","3.1","3.0","2.2","2.1","2.0","1.11","1.10","1.9"],"inLocales":["en","zh-hans","fr","ja","id","it","pt-br","ko","es","el","pl"]}