dgit 13.17 dgit_1 - en to pt translation catalogue (339 entries)

note: type: TH
en: Debian Project
pt: Projeto Debian

note: type: =head1
en: NAME
pt: NOME

note: type: Plain text
en: dgit - git integration with the Debian archive
pt: dgit - integração git com o arquivo Debian

note: type: =head1
en: SYNOPSIS
pt: RESUMO

note: type: =head1
en: DESCRIPTION
pt: DESCRIÇÃO

note: type: Plain text
en: B<dgit> allows you to treat the Debian archive as if it were a git repository.  Conversely, it allows Debian to publish the source of its packages as git branches, in a format which is directly usable by ordinary people.
pt: B<dgit> permite-lhe tratar o arquivo Debian como se fosse um repositório git.  Por outro lado, permite a Debian publicar a fonte dos seus pacotes como ramos git, num formato que é utilizável diretamente por pessoas normais.

note: type: Plain text
en: This is the command line reference.  Please read the tutorial(s):
pt: Isto é a referência de linha de comandos.  Por favor leia os tutorial(is):

note: type: tbl table
en: for users: edit, build and share packages
pt: para utilizadores: editar, compilar e partilhar pacotes

note: type: tbl table
en: for DDs: do a straightforward NMU
pt: para DDs: fazer um NMU direto

note: type: tbl table
en: for maintainers of Debian-native packages
pt: para maintainers de pacotes Debian-nativos

note: type: tbl table
en: for maintainers: a pure-git rebasish workflow
pt: para maintainers: um fluxo de trabalho re-baseado em puro-git

note: type: tbl table
en: for maintainers: a pure-git merging workflow
pt: para maintainers: um fluxo de trabalho de fusão de puro-git

note: type: tbl table
en: for maintainers already using git-buildpackage
pt: para maintainers que já usam o git-buildpackage

note: type: tbl table
en: for sponsors and sponsored contributors
pt: para patrocinadores e contribuidores patrocinados

note: type: tbl table
en: setting up dgit push for a new distro
pt: configurar um dgit push para uma nova distribuição

note: type: Plain text
en: See B<dgit(7)> for detailed information about the data model, common problems likely to arise with certain kinds of package, etc.
pt: Veja B<dgit(7)> para informação detalhada sobre o modelo de dados, problemas comuns que se espera surgirem com certos tipos de pacotes, etc.

note: type: SH
en: OPERATIONS
pt: OPERAÇÕES

note: type: Plain text
en: Consults the archive and dgit-repos to construct the git view of history for I<package> in I<suite> (B<sid> by default)  in a new directory (named B<./>I<package> by default); also, downloads any necessary orig tarballs.
pt: Consulta o arquivo e dgit-repos para construir uma vista git do histórico para I<package> na I<suite> (B<sid> por predefinição)  num directório novo (chamado B<./>I<package> por predefinição); e também, descarrega quaisquer tarballs originais necessários.

note: type: Plain text
en: The suite's git tip is left on the local branch B<dgit/>I<suite> ready for work, and on the corresponding dgit remote tracking branch.  The B<origin> remote will be set up to point to the package's dgit-repos tree for the distro to which I<suite> belongs.
pt: A ponta git da suite é deixada no ramo local B<dgit/>I<suite> pronta a trabalhar, e no ramo de acompanhamento remoto dgit correspondente.  O remoto B<origin> será configurado para apontar para a árvore dgit-repos do pacote para a distribuição da qual a I<suite> pertence.

note: type: Plain text
en: I<suite> may be a combination of several underlying suites in the form I<mainsuite>B<,>I<subsuite>...; see COMBINED SUITES in dgit(7).
pt: I<suite> pode ser uma combinação de várias suites subjacentes no formato I<mainsuite>B<,>I<subsuite>...; veja SUITES COMBINADAS em dgit(7).

note: type: Plain text
en: For your convenience, the B<vcs-git> remote will be set up from the package's Vcs-Git field, if there is one - but note that in the general case the history found there may be different to or even disjoint from dgit's view.  (See also dgit update-vcs-git.)
pt: Para sua conveniência, o B<vcs-git> remoto será configurado a partir do campo Vcs-Git do pacote, se um existir - mas note que no caso geral o histórico encontrado lá pode ser diferente ou mesmo desarticulado da vista do dgit.  (Veja também dgit update-vcs-git.)

note: type: Plain text
en: Consults the archive and git-repos to update the git view of history for a specific suite (and downloads any necessary orig tarballs), and updates the remote tracking branch B<remotes/dgit/dgit/>I<suite>.  If the current branch is B<dgit/>I<suite> then dgit fetch defaults to I<suite>; otherwise it parses debian/changelog and uses the suite specified there.  suite may be a combined suite, as for clone.
pt: Consulta o arquivo e git-repos para atualizar a vista git do histórico para uma suite especificada (e descarrega tarballs de origem se necessário), e atualiza o ramo de acompanhamento remoto B<remotes/dgit/dgit/>I<suite>.  Se o ramo atual for B<dgit/>I<suite> então o dgit fetch predefine para I<suite>; caso contrário analisa debian/changelog e usa a suite especificada lá.  Suite pode ser uma suite combinada, como para clone.

note: type: Plain text
en: Does dgit fetch, and then merges the new head of the remote tracking branch B<remotes/dgit/dgit/>I<suite> into the current branch.
pt: Faz dgit fetch, e depois funde o novo cabeçalho do ramo de acompanhamento remoto B<remotes/dgit/dgit/>I<suite> no ramo atual.

note: type: Plain text
en: Checks out the local branch B<dgit/>I<suite>.
pt: Confere o ramo local B<dgit/>I<suite>.

note: type: Plain text
en: If the branch does not exist, dgit checkout creates it, and sets it up the same way as dgit clone would.  In that case, if the archive remote tracking branch does not exist, dgit checkout will do a dgit fetch first.
pt: Se o ramo não existir, o dgit checkout cria-o, e configura-o do mesmo modo que o dgit clone faria.  Nesse caso, se o ramo de acompanhamento remoto do arquivo não existir, o dgit checkout irá fazer um dgit fetch primeiro.

note: type: Plain text
en: NB: dgit checkout will only do a fetch if it has to.  If you already have the suite branch, and want to merge your branch with updates from the archive, use dgit pull.
pt: Note Bem: dgit checkout irá apenas fazer fetch se precisar.  Se você já tiver um ramo de suite, e quer fundir o seu ramo com atualizações do arquivo, use dgit pull.

note: type: Plain text
en: dgit checkout will normally need to access the archive server, to canonicalise the provided suite name.  The exception is if you specify the canonical name, and the branch (or tracking branch) already exists.
pt: O dgit checkout irá precisar normalmente de aceder ao servidor de arquivo, para canonizar o nome de suite fornecido.  A excepção é se você especificar o nome canónico, e o ramo (ou ramo de acompanhamento) já existir.

note: type: Plain text
en: Runs B<dpkg-buildpackage> with some suitable options.  Options and arguments after build will be passed on to dpkg-buildpackage.  It is not necessary to use dgit build when using dgit; it is OK to use any approach which ensures that the generated source package corresponds to the relevant git commit.
pt: Corre B<dpkg-buildpackage> com algumas opções apropriadas.  As opções e argumentos após compilação serão passadas ao dpkg-buildpackage.  Não é necessário usar dgit build quando se usa dgit; é OK usar uma abordagem que assegure que o pacote fonte gerado corresponde ao cometido git relevante.

note: type: Plain text
en: Tagging, signing and actually uploading should be left to dgit push.
pt: O etiquetar, assinar e o envio real devem ser deixados para o dgit push.

note: type: Plain text
en: dgit's build operations access the network, to get the -v option right.  See -v, below.
pt: As operações de compilação do dgit acedem à rede, para obter a opção -v certa.  Veja -v, em baixo.

note: type: Plain text
en: Builds the source package, and a changes file for a prospective source-only upload, using B<dpkg-source>.
pt: Compila o pacote fonte, e um ficheiro de alterações para um prospetivo envio de apenas-fonte, usando o B<dpkg-source>.

note: type: Plain text
en: The output is left in I<package>B<_>I<version>B<.dsc> and I<package>B<_>I<version>B<_source.changes>.
pt: O resultado é deixado em I<package>B<_>I<version>B<.dsc> e I<package>B<_>I<version>B<_source.changes>.

note: type: Plain text
en: Tagging, signing and actually uploading should be left to dgit push-source, or dgit push.
pt: O etiquetar, assinar e o envio real deve ser deixado para dgit push-source, ou dgit push.

note: type: Plain text
en: B<dgit build-source> checks that the generated source package corresponds to the git HEAD (as canonicalised with the specified quilt mode, if applicable).  The other B<dgit *build*> options to not perform this check at build time, instead leaving it to B<dgit push>.
pt: B<dgit build-source> verifica que o pacote fonte gerado corresponde ao CABEÇALHO git (como canonizado com o modo quilt especificado, se aplicável).  As outras opções de B<dgit *build*> para não efetuar esta verificação durante a compilação, em vez disso, deixam isto para o B<dgit push>.

note: type: Plain text
en: Cleans the current working tree (according to the --clean= option in force).
pt: Limpa a árvore de trabalho atual (de acordo com a opção --clean= em força).

note: type: TP
en: B<dgit update-vcs-git> [I<suite>|B<.>] [B<-->] [I<git fetch options>]
pt: B<dgit update-vcs-git> [I<suite>|B<.>] [B<-->] [I<opções do git fetch>]

note: type: Plain text
en: Sets up, or updates the url of, the vcs-git remote, and (unless B<-> was specified)  runs git fetch on it.
pt: Define, ou atualiza o seu url, o vcs-git remoto, e (a menos que B<-> seja especificado)  corre git fetch nele.

note: type: Plain text
en: By default, the Vcs-Git field of the .dsc from Debian sid is used, as that is probably most up to date.  Another suite may be specified, or B<.> to indicate that the Vcs-Git of the cwd's debian/control should be used instead.
pt: Por predefinição, é usado o campo Vcs-Git do .dsc de Debian sid, pois esse é provavelmente o mais atualizado.  Pode ser especificada outra suite, ou B<.> para indicar que o Vcs-Git do debian/control do cwd deve ser usado em vez deste.

note: type: Plain text
en: Print a usage summary.
pt: Escreve um sumário de utilização.

note: type: Plain text
en: Constructs the source package, uses B<sbuild> to do a binary build, and uses mergechanges to merge the source and binary changes files.  Options and arguments after sbuild will be passed on to sbuild.  The output is left in I<package>B<_>I<version>B<_multi.changes>.
pt: Constrói o pacote fonte, usa B<sbuild> para fazer compilação binária, e usa mergechanges para fundir os ficheiros de alterações de fonte e binário.  Opções e argumentos após sbuild serão passadas ao sbuild.  O resultado é deixado em I<pacote>B<_>I<versão>B<_multi.changes>.

note: type: Plain text
en: Constructs the source package, uses B<pbuilder> to do a binary build, and uses mergechanges to merge the source and binary changes files.  The output is left in I<package>B<_>I<version>B<_multi.changes>.
pt: Constrói o pacote fonte, usa B<pbuilder> para fazer compilação binária, e usa mergechanges para fundir os ficheiros de alterações de fonte e binário.  O resultado é deixado em I<pacote>B<_>I<versão>B<_multi.changes>.

note: type: Plain text
en: You should ensure that your dgit --build-products-dir setting matches your pbuilder --buildresult.
pt: Você deve assegurar que a sua definição de dgit --build-products-dir corresponde ao seu pbuilder --buildresult.

note: type: Plain text
en: The I<debbuildopts> are passed to pbuilder using its --debbuildopts option.  If you want to pass other options to pbuilder, use the B<--pbuilder:> dgit option as described below (remember that dgit options should appear between B<dgit> and B<pbuilder>).
pt: Os I<debbuildopts> são passados ao pbuilder usando a sua opção --debbuildopts.  Se você quiser passar outras opções ao pbuilder, use a opção do dgit B<--pbuilder:> como descrita em baixo (lembre-se que as opções do dgit devem aparecer entre B<dgit> e B<pbuilder>).

note: type: Plain text
en: You should ensure that in your pbuilderrc you do B<not> have the setting B<SOURCE_ONLY_CHANGES=yes> as this may cause trouble.
pt: Você deve assegurar no seu pbuilderrc que B<não> tem a definição B<SOURCE_ONLY_CHANGES=yes> pois isto pode causar problemas.

note: type: Plain text
en: Like B<dgit pbuilder>, but uses B<cowbuilder> instead of B<pbuilder.>
pt: Como o B<dgit pbuilder>, mas usa B<cowbuilder> em vez de B<pbuilder.>

note: type: Plain text
en: Runs B<git-buildpackage> with some suitable options.  Options and arguments after gbp-build will be passed on to git-buildpackage.
pt: Corre B<git-buildpackage> com algumas opções apropriadas.  As opções e argumentos após gbp-build são passadas ao git-buildpackage.

note: type: Plain text
en: By default this uses --quilt=gbp, so HEAD should be a git-buildpackage style branch, not a patches-applied branch.
pt: Por predefinição isto usa --quilt=gbp, assim o CABEÇALHO deve ser um ramo do estilo git-buildpackage, e não um ramo de patches aplicadas.

note: type: Plain text
en: Does an `upload': sends the current HEAD to dgit-repos (as git commits), and to the archive (as a source package, built by this command).
pt: Faz um `upload': envia o CABEÇALHO atual para dgit-repos (como cometidos git), e para o arquivo (como um pacote fonte, compilado por este comando).

note: type: Plain text
en: This is the usual way to upload to Debian.  It is like saying "update the source code in the archive to match my git HEAD, and let the autobuilders do the rest."
pt: Este é o modo usual de enviar para Debian.  É como dizer "atualiza o código fonte no arquivo para corresponder ao meu CABEÇALHO git, e deixa os auto-compiladores fazer o resto."

note: type: Plain text
en: In more detail: dgit push-source builds a source package from HEAD.  It then pushes the HEAD to the suite's dgit-repos branch, adjusts the .changes to include any .origs which the archive lacks and exclude .origs which the archive has (so -sa and -sd are not needed when building for dgit push), makes a signed git tag, edits the .dsc to contain the dgit metadata field, runs debsign to sign the upload (.dsc and .changes), pushes the signed tag, and finally uses dput to upload the .changes to the archive.
pt: Mais detalhado: O dgit push-source compila um pacote fonte a partir do CABEÇALHO.  Depois empurra o CABEÇALHO para o ramo dgit-repos da suite, ajusta o .changes para incluir quaisquer .origs que estão em falta no arquivo e exclui .origs que o arquivo tem (assim -sa e -sd não são necessários quando se compila para dgit push), faz uma etiqueta git assinada, edita o .dsc para conter um campo de metadados do dgit, corre o debsign para assinar o envio (.dsc e .changes), empurra a etiqueta assinada, e finalmente usa o dput para enviar o .changes para o arquivo.

note: type: Plain text
en: dgit push always uses the package, suite and version specified in the debian/changelog and the .dsc, which must agree.  If the command line specifies a suite then that must match too.
pt: O dgit push usa sempre o pacote, suite e versão especificados no debian/changelog e o .dsc, o qual tem de concordar.  Se a linha de comandos especificar uma suite então essa também tem de corresponder.

note: type: Plain text
en: When used on a git-debrebase branch, dgit calls git-debrebase to prepare the branch for source package upload and push.
pt: Quando usado num ramo git-debrebase, o dgit chama git-debrebase para preparar o ramo para envio e empurrar de pacote fonte.

note: type: Plain text
en: With B<-C>, dgit push-source performs a dgit push-built, additionally ensuring that no binary packages are uploaded.
pt: Com B<-C>, dgit push-source efetua um dgit push-built, assegurando adicionalmente que nenhuns pacotes binário são enviados.

note: type: Plain text
en: Does an `upload' of a previously built package, possibly including binaries.  Sends the current HEAD to dgit-repos (as git commits); and, sends the previously built source package and binaries to the archive.
pt: Faz um `upload' de um pacote previamente compilado, possivelmente incluindo binários.  Envia o CABEÇALHO atual para dgit-repos (como cometidos git); e, envia o pacote fonte e binários previamente compilado para o arquivo.

note: type: Plain text
en: The package must already have been built ready for upload, with the .dsc and .changes left in the parent directory.  It is normally best to do the build with dgit too (e.g. with dgit sbuild): some existing build tools pass unhelpful options to dpkg-source et al by default, which can result in the built source package not being identical to the git tree.
pt: O pacote tem de já estar compilado e pronto para enviar, com o .dsc e .changes deixados no directório pai.  É normalmente melhor fazer a compilação também com o dgit (ex. com dgit sbuild): algumas ferramentas de compilação existentes passam opções que em nada ajudam ao dpkg-source por predefinição, o que pode resultar no pacote fonte compilado não ser idêntico à árvore do git.

note: type: Plain text
en: dgit will check that the .dsc corresponds exactly to the current HEAD, ensuring that all users, whether of the dgit git view, or of the traditional archive, see the same source package.
pt: O dgit irá verificar que o .dsc corresponde exatamente ao CABEÇALHO atual, assegurando que todos os utilizadores, sejam da vista git do dgit, ou do arquivo tradicional, vejam o mesmo pacote fonte.

note: type: Plain text
en: Pushes the contents of the specified directory on a remote machine.  This is like running dgit push on build-host with src-dir as the current directory; however, signing operations are done on the invoking host.  This allows you to do a push when the system which has the source code (and any built binaries) has no access to the key:
pt: Empurra o conteúdo do directório especificado numa máquina remota.  Isto é como correr dgit push em build-host com src-dir como o directório atual; no entanto, as operações de assinar são feitas na máquina invocadora.  Isto permite-lhe fazer um push quando o sistema que tem o código fonte (e quaisquer binários compilados) não tem acesso à chave:

note: type: tbl table
en: Clone on build host (dgit clone)
pt: Clonar na máquina de compilação (dgit clone)

note: type: tbl table
en: Edit code on build host (edit, git commit)
pt: Editar código na maquina de compilação (edit, git commit)

note: type: tbl table
en: Build package on build host (dgit build)
pt: Compilar pacote na máquina de compilação (dgit build)

note: type: tbl table
en: Test package on build host or elsewhere (dpkg -i, test)
pt: Testar pacote na máquina de compilação ou noutro lado qualquer (dpkg -i, test)

note: type: tbl table
en: Upload by invoking dgit rpush on host with your GPG key.
pt: Enviar ao invocar dgit rpush na máquina com a sua chave GPG.

note: type: Plain text
en: However, the build-host must be able to ssh to the dgit repos.  If this is not already the case, you must organise it separately, for example by the use of ssh agent forwarding.
pt: No entanto, a máquina de compilação tem de ser capaz de ssh ao repositório dgit.  Se não for este já o caso, você tem de o organizar separadamente, por exemplo pelo uso de agente de encaminhamento de ssh.

note: type: Plain text
en: The remaining arguments are treated just as dgit push-source or dgit push-built would handle them.
pt: Os argumentos restantes são tratados tal como o dgit push-source ou dgit push-built os iria tratar.

note: type: Plain text
en: build-host and build-dir can be passed as separate arguments; this is assumed to be the case if the first argument contains no : (except perhaps one in [ ], to support IPv6 address literals).
pt: build-host e build-dir podem ser passados como argumentos separados; isto é assumido que seja o caso se o primeiro argumento conter nenhum : (excepto talvez um em [ ], para suportar endereços IPv6 literais).

note: type: Plain text
en: You will need similar enough versions of dgit on the build-host and the invocation host.  The build-host needs gnupg installed, with your public key, and that of any sponsee, in its keyring (but not your private key, obviously).
pt: Você vai precisar de versões semelhantes o suficiente do dgit na máquina de compilação e na máquina de invocação.  A maquina de compilação precisa do gnupg instalado, com a sua chave pública, e a de qualquer patrocinado, no seu chaveiro (mas não a sua chave privada, obviamente).

note: type: Plain text
en: Configurable aliases for B<dgit push-built> and B<dgit rpush-built>.  These aliases will in the future change to mean B<dgit push-source> and B<dgit rpush-source>, and therefore they currently generate a warning.
pt: Nomes alternativos configuráveis para B<dgit push-built> e B<dgit rpush-built>.  Estes aliases irão no futuro alterar para significar B<dgit push-source> e B<dgit rpush-source>, e por isto eles atualmente geram um aviso.

note: type: Plain text
en: The behaviour of dgit push is controlled by the B<dgit.default.push-subcmd> git config option:
pt: O comportamento do dgit push é controlado pela opção de configuração de git B<dgit.default.push-subcmd>:

note: type: tbl table
en: runs B<dgit push-source>
pt: corre B<dgit push-source>

note: type: tbl table
en: future default
pt: predefinição futura

note: type: tbl table
en: and runs B<dgit push-built>
pt: e correr B<dgit push-built>

note: type: tbl table
en: warns, and runs B<dgit push-built>
pt: avisa, e corre B<dgit push-built>

note: type: tbl table
en: current default
pt: predefinição atual

note: type: tbl table
en: fails
pt: falha

note: type: Plain text
en: For dgit rpush, the behaviour is controlled by B<dgit.default.rpush-subcmd>, falling back to B<dgit.default.push-subcmd> if that is not set.  Because dgit rpush is not typically run in a git working tree, only global git config options (and B<-c> command line options) are relevant.
pt: Para o  dgit rpush, o comportamento é controlado por B<dgit.default.rpush-subcmd>, caindo para B<dgit.default.push-subcmd> se não estiver definido.  Porque o dgit rpush não é corrido tipicamente numa árvore de trabalho git, apenas opções globais de configuração git (e opções de linha de comandos B<-c>) são relevantes.

note: type: Plain text
en: These settings can safely be passed to older dgit (via B<-c);> the value B<built> will be supported indefinitely.  This should be used in scripts that need to work with both old versions of dgit (that don't have B<push-built>)  and new versions (where B<push-source> is the default).
pt: Estas definições podem ser passadas em segurança a dgit mais antigo (via B<-c);> o valor B<built> irá ser suportado indefinidamente.  Isto deve ser usado em scripts que precisam de trabalhar com ambas versões antigas do dgit (que não têm B<push-built>)  e novas versões (onde B<push-source> é a predefinição).

note: type: Plain text
en: Configure the current working tree the way that dgit clone would have set it up.  Like running B<dgit setup-useremail>, B<setup-mergechangelogs> and B<setup-gitattributes> (but only does each thing if dgit is configured to do it automatically).  You can use these in any git repository, not just ones used with the other dgit operations.  Does B<not> run B<update-vcs-git> (as that requires Debian packaging information).
pt: Configura a árvore de trabalho atual da maneira que o dgit clone a iria configurar.  Como correr B<dgit setup-useremail>, B<setup-mergechangelogs> e B<setup-gitattributes> (mas apenas faz cada uma se o dgit estiver configurado para o fazer automaticamente).  Você pode usar estes em qualquer repositório git, não apenas naqueles usados com outras operações do dgit.  B<Não> corre B<update-vcs-git> (pois isso requer informação de empacotamento de Debian).

note: type: Plain text
en: Set the working tree's user.name and user.email from the distro-specific dgit configuration (B<dgit-distro.>I<distro>B<.user-name> and B<.user-email>), or DEBFULLNAME or DEBEMAIL.
pt: Define o nome.utilizador e o email.utilizador de árvore de trabalho a partir da configuração dgit específica-da-distribuição (B<dgit-distro.>I<distro>B<.user-name> e B<.user-email>), ou DEBFULLNAME ou DEBEMAIL.

note: type: Plain text
en: Configures a git merge helper for the file B<debian/changelog> which uses B<dpkg-mergechangelogs>.
pt: Configura um ajudante de fusão git para o ficheiro B<debian/changelog> o qual usa B<dpkg-mergechangelogs>.

note: type: Plain text
en: Set up the working tree's B<.git/info/attributes> to disable all transforming attributes for all files.  This is done by defining a macro attribute, B<dgit-defuse-attrs,> and applying it to B<*>.  For why, see B<GITATTRIBUTES> in B<dgit(7)>.  Note that only attributes affecting the working tree are suppressed.  git-archive may remain exciting.
pt: Define os B<.git/info/attributes> da árvore de trabalho para desativar todos os atributos de transformação para todos os ficheiros.  Isto é feito ao definir um atributo macro, B<dgit-defuse-attrs,> e aplicando-o a B<*>.  Para o razão disto, veja B<GITATTRIBUTES> em B<dgit(7)>.  Note que apenas atributos que afetam a árvore de trabalho são suprimidos.  O git-archive pode continuar excitante.

note: type: Plain text
en: If there is an existing macro attribute line B<[attr]dgit-defuse-attrs> in .git/info/attributes, but it is insufficient, because it was made by an earlier version of dgit and git has since introduced new transforming attributes, this modifies the macro to disable the newer transformations.
pt: Se houver uma linha de atributo macro existente B<[attr]dgit-defuse-attrs> em .git/info/attributes, mas for insuficiente, porque foi feita por uma versão anterior do dgit e o git desde isso introduziu novos atributos de transformação, isto modifica a macro para desativar as transformações mais recentes.

note: type: Plain text
en: (If there is already a macro attribute line B<[attr]dgit-defuse-attrs> in .git/info/attributes which does what dgit requires (whatever files it effects), this operation does nothing further.  This fact can be used to defeat or partially defeat dgit setup-gitattributes and hence dgit setup-new-tree.)
pt: (Se já existir uma linha de atributo macro B<[attr]dgit-defuse-attrs> em .git/info/attributes a qual faz o que o dgit requer (seja quais ficheiros afete), esta operação não faz mais nada.  Este facto pode ser usado para derrotar ou derrotar parcialmente o dgit setup-gitattributes e portanto o dgit setup-new-tree.)

note: type: Plain text
en: `3.0 (quilt)' format source packages need changes representing not only in-tree but also as patches in debian/patches.  dgit quilt-fixup checks whether this has been done; if not, dgit will make appropriate patches in debian/patches and also commit the resulting changes to git.
pt: Pacotes fonte de formato `3.0 (quilt)' precisam de representação das alterações não apenas na-árvore mas também como patches em debian/patches.  O dgit quilt-fixup verifica se isto foi feito; se não, o dgit irá fazer patches apropriadas em debian/patches e também cometer as alterações resultantes para git.

note: type: Plain text
en: This is normally done automatically by dgit build and dgit push.
pt: Isto é normalmente feito automaticamente pelo dgit build e dgit push.

note: type: Plain text
en: dgit will try to turn each relevant commit in your git history into a new quilt patch.  dgit cannot convert nontrivial merges, or certain other kinds of more exotic history.  If dgit can't find a suitable linearisation of your history, by default it will fail, but you can ask it to generate a single squashed patch instead.
pt: O dgit irá tentar converter cada cometido relevante no seu histórico git numa nova patch quilt.  O dgit não pode converter fusões não-triviais, ou certos tipos de histórico mais exótico.  Se o dgit não puder encontrar uma linearização apropriada do seu histórico, por predefinição irá falhar, mas você pode pedir-lhe para gerar uma única patch esmagada em vez disto.

note: type: Plain text
en: When used with a git-debrebase branch, dgit will ask git-debrebase to prepare patches.  However, dgit can make patches in some situations where git-debrebase fails, so dgit quilt-fixup can be useful in its own right.  To always use dgit's own patch generator instead of git-debrebase make-patches, pass --git-debrebase=true to dgit.
pt: Quando usado com um ramo git-debrebase, o dgit irá pedir ao git-debrebase para preparar patches.  No entanto, o dgit pode fazer patches em algumas situações onde o git-debrebase falha, assim dgit quilt-fixup pode ser útil por seu próprio direito.  Para usar sempre o próprio gerador de patch do dgit em vez de git-debrebase make-patches, passe --git-debrebase=true ao dgit.

note: type: Plain text
en: See B<FORMAT 3.0 (QUILT)> in B<dgit(7)>.
pt: Veja B<FORMATO 3.0 (QUILT)> em B<dgit(7)>.

note: type: TP
en: B<dgit import-dsc> [I<sub-options>] I<../path/to/.dsc> [B<+>|B<..>]branch
pt: B<dgit import-dsc> [I<sub-opções>] I<../caminho/para/.dsc> [B<+>|B<..>]ramo

note: type: Plain text
en: Import a Debian-format source package, specified by its .dsc, into git, the way dgit fetch would do.
pt: Importa um pacote fonte de formato Debian, especificado pelo seu .dsc, para git, da maneira que o dgit fetch faria.

note: type: Plain text
en: This does about half the work of dgit fetch: it will convert the .dsc into a new, orphan git branch.  Since dgit has no access to a corresponding source package archive or knowledge of the history it does not consider whether this version is newer than any previous import or corresponding git branches; and it therefore does not make a pseudomerge to bind the import into any existing git history.
pt: Isto faz cerca de metade do trabalho do dgit fetch: irá converter o .dsc num ramo git órfão novo.  Como o dgit não tem acesso a um arquivo de pacote fonte correspondente ou conhecimento do histórico ele não considera se esta versão é mais recente que qualquer importação anterior ou ramos git correspondentes; e por isso não faz uma pseudo-fusão para vincular a importação a qualquer histórico git existente.

note: type: Plain text
en: Because a .dsc can contain a Dgit field naming a git commit (which you might not have), and specifying where to find that commit (and any history rewrite table), import-dsc might need online access.  If this is a problem (or dgit's efforts to find the commit fail), consider --no-chase-dsc-distro or --force-import-dsc-with-dgit-field.
pt: Porque um .dsc pode conter um campo Dgit a nomear um cometido git (o qual você pode não ter), e especificar onde encontrar tal cometido (e qualquer tabela de rescrita de histórico), o import-dsc pode precisar de acesso online.  Se isto for um problema (ou se o esforço do dgit para encontrar o cometido falhar), considere --no-chase-dsc-distro ou --force-import-dsc-with-dgit-field.

note: type: Plain text
en: There is only one sub-option:
pt: Existe apenas uma sub-opção:

note: type: Plain text
en: B<--require-valid-signature> causes dgit to insist that the signature on the .dsc is valid (using the same criteria as dpkg-source -x).  Otherwise, dgit tries to verify the signature but the outcome is reported only as messages to stderr.
pt: B<--require-valid-signature> faz o dgit insistir que a assinatura no .dsc é válida (usando o mesmo critério que dpkg-source -x).  Caso contrário, o dgit tenta verificar a assinatura mas o resultado é reportado apenas como mensagens para o stderr.

note: type: Plain text
en: If I<branch> is prefixed with B<+> then if it already exists, it will be simply overwritten, no matter its existing contents.  If I<branch> is prefixed with B<..> then if it already exists and dgit actually imports the dsc (rather than simply reading the git commit out of the Dgit field), dgit will make a pseudomerge so that the result is necessarily fast forward from the existing branch.  Otherwise, if I<branch> already exists, dgit will stop with an error message.
pt: Se I<branch> for prefixado com B<+> então se já existir, será simplesmente sobrescrito, independentemente do conteúdo existente.  Se I<branch> for prefixado com B<..> então se já existir e o dgit realmente importar o dsc (em vez de ler simplesmente o cometido git a partir do campo Dgit), o dgit irá fazer uma pseudo-fusão para que o resultado seja necessariamente de avanço rápido a partir do ramo existente.  Caso contrário, se I<branch> já existir, o dgit irá parar com uma mensagem de erro.

note: type: Plain text
en: If I<branch> does not start with refs/, refs/heads/ is prepended.
pt: Se I<branch> não começar com refs/, é precedido com refs/heads/.

note: type: TP
en: B<dgit>download-unfetched-origsB< [>I<options>]
pt: B<dgit>download-unfetched-origsB< [>I<opções>]

note: type: Plain text
en: Consults the archive for any orig tarballs for this package and upstream version, and downloads them.
pt: Consulta o arquivo por quaisquer tarballs de origem para este pacote e versão de autor, e descarrega-os.

note: type: Plain text
en: The suite declared in the changelog will be checked first.
pt: A suite declarada no changelog será verificada primeiro.

note: type: Plain text
en: Failing that, the whole archive will be searched for suitable origs.  If there are multiple sets of origs that may apply, fails with exit status 5.  This can happen if different uploads of the same upstream version have different origs.
pt: Falhando isso, será procurado no arquivo inteiro por origs apropriados.  Se existirem múltiplos conjuntos de origs que possam ser aplicados, falha com estado de saída 5.  Isto pode acontecer se diferentes envios da mesma versão de autor tiverem diferentes origs.

note: type: Plain text
en: If (some of) the selected origs are already present locally, they aren't re-downloaded, but their checksums are checked against data from the archive.
pt: Se os origs selecionados (alguns deles) já estiverem presentes localmente, eles não são re-descarregados, mas os seus sumários de verificação são verificados contra dados a partir do arquivo.

note: type: Plain text
en: download-unfetched-origs supports some subcommand-specific options:
pt: O download-unfetched-origs suporta algumas opções específicas de sub-comandos:

note: type: TP
en: B<--write-sha256sums=>I<file>
pt: B<--write-sha256sums=>I<ficheiro>

note: type: Plain text
en: Writes checksums of the selected origs to I<file>, in sha256sum format.  The files listed are a set suitable for a new upload or build, of the this package and version.  The checksums file is written and correct, even if dgit download-unfetched-origs exits with status 3.
pt: Escreve sumários de verificação dos origs selecionados em I<ficheiro>, em formato sha256sum.  Os ficheiros listados são um conjunto apropriado para um novo envio ou compilação, deste pacote e versão.  O ficheiro de sumários de verificação é escrito e corrigido, mesmo que dgit download-unfetched-origs termine com estado 3.

note: type: Plain text
en: Prints version information and exits.
pt: Escreve informação de versão e termina.

note: type: Plain text
en: Tries to fetch a copy of the source code for the dgit-repos-server, as actually being used on the dgit git server, as a git tree.
pt: Tenta obter uma cópia do código fonte para o dgit-repos-server, como sendo realmente usado no servidor git do dgit, como uma árvore git.

note: type: Plain text
en: Prints the url used by dgit clone-dgit-repos-server.  This is hopefully suitable for use as a git remote url.  It may not be usable in a browser.
pt: Escreve o url usado pelo dgit clone-dgit-repos-server.  Espera-se que isto seja apropriado para usar como um url remoto de git.  Pode não ser utilizável num navegador.

note: type: Plain text
en: Prints the -i and -I arguments which must be passed to dpkg-souce to cause it to exclude exactly the .git directory and nothing else.  The separate arguments are unquoted, separated by spaces, and do not contain spaces.
pt: Escreve os argumentos -i e -I que têm de ser passados ao dpkg-souce para fazer com que execute exatamente o directório .git e mais nada.  Os argumentos separados não são cotados, separados por espaços, e não contêm espaços.

note: type: Plain text
en: Constructs a tree-ish approximating the patches-unapplied state of your 3.0 (quilt) package, and prints the git object name to stdout.  This requires appropriate .orig tarballs.  This tree object is identical to your .origs as regards upstream files.  The contents of the debian subdirectory is not interesting and should not be inspected; except that debian/patches will be identical to your HEAD.
pt: Constrói uma tree-ish aproximando o estado de patches-não-aplicadas do seu pacote 3.0 (quilt), e escreve o nome de objeto git no stdout.  Isto requer tarballs .orig apropriados.  Este objeto árvore é idêntico ao seu .origs com respeito a ficheiros do autor.  O conteúdo do sub-directório debian não é interessante e não deve ser inspecionado; excepto que debian/patches será idêntico ao seu CABEÇALHO.

note: type: Plain text
en: To make this operate off-line, the access configuration key which is used to determine the build-products-dir is the uncanonicalised version of the suite name from the changelog, or (of course) dgit.default.build-products-dir.  See ACCESS CONFIGURATION, below.
pt: Para fazer isto operar off-line, a chave de configuração de acesso que é usada para determinar o build-products-dir é a versão não canonizada do nome da suite a partir do registo de alterações, ou (claro) dgit.default.build-products-dir.  Veja CONFIGURAÇÃO DE ACESSO, e baixo.

note: type: Plain text
en: This function is primarily provided for the benefit of git-debrebase.
pt: Esta função é fornecida principalmente para o benefício de git-debrebase.

note: type: =head1
en: OPTIONS
pt: OPÇÕES

note: type: Plain text
en: Use I<keyid> for signing the tag and the upload.  The default comes from the distro's B<keyid> config setting (see CONFIGURATION, below), or failing that, the uploader trailer line in debian/changelog.
pt: Usa I<keyid> para assinar a etiqueta e o envio  A predefinição vem da definição de configuração B<keyid> da distribuição (veja CONFIGURAÇÃO, em baixo), ou falhando isso, da linha atrelada de quem enviou em debian/changelog.

note: type: Plain text
en: does not sign tags or uploads (meaningful only with push).
pt: Não assina etiquetas nem envios (com significado apenas com push).

note: type: TP
en: B<-p>I<package>
pt: B<-p>I<pacote>

note: type: Plain text
en: Specifies that we should process source package I<package>.
pt: Especifica que devemos processar o pacote fonte I<pacote>.

note: type: Plain text
en: For dgit fetch and dgit pull, uses this value rather than looking in debian/control or debian/changelog.
pt: Para dgit fetch e dgit pull, usa este valor em vez de procurar em debian/control ou debian/changelog.

note: type: Plain text
en: For dgit rpush, specifies that the invoking host should be willing to sign only a .dsc or .changes file for the source package I<package>.
pt: Para dgit rpush, especifica que a máquina que invoca deverá está disposta a assinar apenas um ficheiro .dsc ou .changes para o pacote fonte I<pacote>.

note: type: Plain text
en: Use B<git clean -xdf> to clean the working tree, rather than running the package's rules clean target.
pt: Usa B<git clean -xdf> para limpar a árvore de trabalho, em vez de correr o alvo de limpeza de regras do pacote.

note: type: Plain text
en: This will delete all files which are not tracked by git.  (Including any files you forgot to git add.)
pt: Isto vai apagar todos os ficheiros que não são seguidos pelo git.  (Incluindo quaisquer ficheiros que você esqueceu de adicionar ao git).

note: type: Plain text
en: B<--clean=>I<...> options other than dpkg-source are useful when the package's clean target is troublesome, or to avoid needing the build-dependencies.
pt: Outras opções B<--clean=>I<...> além de dpkg-source são úteis quando o alvo de limpeza do pacote é problemático, ou para evitar precisar das dependências de compilação.

note: type: Plain text
en: dgit will only actually clean the tree if it needs to (because it needs to build the source package or binaries from your working tree).  Otherwise it will just check that there are no untracked unignored files.  See --clean=git[-ff],always, below.
pt: O dgit irá apenas limpar a árvore se precisar (porque precisa de compilar o pacote fonte ou binários a partir da árvore de trabalho).  Caso contrário irá apenas verificar que não existem ficheiros não seguidos e não ignorados.  Veja --clean=git[-ff],always, em baixo.

note: type: Plain text
en: Use B<git clean -xdff> to clean the working tree.  Like git clean -xdf but it also removes any subdirectories containing different git trees (which only unusual packages are likely to create).
pt: Usa B<git clean -xdff> para limpar a árvore de trabalho.  Como git clean -xdf mas também remove quaisquer sub-directórios que contenham árvores git diferentes (o que apenas pacotes não usuais são prováveis de criar).

note: type: Plain text
en: Like --clean=git, but always does the clean and not just a check, deleting any untracked un-ignored files.
pt: Como --clean=git, mas faz sempre a limpeza e não apenas uma verificação, apagando quaisquer ficheiros não seguidos e não ignorados.

note: type: Plain text
en: Merely check that the tree is clean (does not contain uncommitted files).  Avoids running rules clean, and can avoid needing the build-dependencies.
pt: Verifica meramente que a árvore está limpa (que não contém ficheiros não cometidos).  Evita correr a limpeza de regras, e pode evitar o precisar das dependências de compilação.

note: type: Plain text
en: With B<,ignores> or B<-wci>, untracked files covered by .gitignore are tolerated, so only files which show up as B<?> in git status (ie, ones you maybe forgot to git add)  are treated as a problem.
pt: Com B<,ignores> ou B<-wci>, os ficheiros não seguidos cobertos por .gitignore são tolerados, assim apenas ficheiros que aparecem como B<?> no estado do git (isto é, aqueles que você talvez esqueceu de adicionar ao git) são tratados como um problema.

note: type: Plain text
en: Do not clean the tree, nor check that it is clean.  Avoids running rules clean, and can avoid needing the build-dependencies.  If there are files which are not in git, or if the build creates such files, a subsequent dgit push will fail.
pt: Não limpa a árvore, nem verifica se está limpa.  Evita correr limpeza de regras, e pode evitar precisar de dependências de compilação.  Se existirem ficheiros que não estão em git, ou se a compilação criar tais ficheiros, um dgit push subsequente irá falhar.

note: type: Plain text
en: Use dpkg-buildpackage to do the clean, so that the source package is cleaned by dpkg-source running the package's clean target.  --clean=dpkg-source is the default.
pt: Usa dpkg-buildpackage para fazer a limpeza, para que o pacote fonte seja limpo pelo dpkg-source correndo o alvo de limpeza do pacote.  --clean=dpkg-source é a predefinição.

note: type: Plain text
en: Without the extra B<d>, requires the package's build dependencies.
pt: Sem o B<d> extra, requer as dependências de compilação do pacote.

note: type: Plain text
en: With B<...>-d or B<-wdd>, the build-dependencies are not checked (due to passing B<-d> to dpkg-buildpackage), which violates policy, but may work in practice.
pt: Com B<...>-d ou B<-wdd>, as dependências de compilação não são verificadas (devido a passar B<-d> ao dpkg-buildpackage), o que viola a política, mas pode funcionar para praticar.

note: type: Plain text
en: The rules clean target will only be run if it is needed: when dgit is going to build source or binary packages from your working tree, rather than from your git branch (for example because of --include-dirty or because the binary package build uses your working tree).
pt: O alvo de limpeza de regras só será corrido se for necessário: quando o dgit vai compilar pacotes fonte ou binário a partir da sua árvore de trabalho, em vez do seu ramo git (por exemplo devido a --include-dirty ou porque a compilação do pacote binário usa a sua árvore de trabalho).

note: type: Plain text
en: In all cases, dgit will check that there are (after rules clean, if applicable) no untracked un-ignored files, in case these are files you forgot to git add.  (Except that this check is not done for a `3.0 (quilt)' package when dgit has to apply patches, dirtily, to the working tree.)  If your package does not have a good .gitignore you will probably need --clean=dpkg-source,no-check aka -wdn.
pt: Em todos os casos, o dgit irá verificar que não existem (após a limpeza de regras, se aplicável) nenhuns ficheiros não seguidos e não ignorados, no caso destes serem ficheiros que você esqueceu de adicionar ao git.  (Excepto que esta verificação não é feita para um pacote `3.0 (quilt)' quando o dgit tem de aplicar patches, de maneira suja, na árvore de trabalho.)  Se o seu pacote não tiver um bom .gitignore você vai provavelmente precisar de --clean=dpkg-source,no-check também conhecido por -wdn.

note: type: Plain text
en: Like --clean=dpkg-source, but does not care about untracked un-ignored files.
pt: Como --clean=dpkg-source, mas não se interessa por ficheiros não seguidos não ignorados.

note: type: Plain text
en: Like --clean=dpkg-source, but fails even on ignored untracked files.  This could perhaps be used to detect bugs in your rules clean target.
pt: Como --clean=dpkg-source, mas falha mesmo com ficheiros não seguidos ignorados.  Isto pode talvez ser usado para detetar bugs no seu alvo de limpeza de regras.

note: type: Plain text
en: The package is, or may be, new in this suite.  Without this, dgit will refuse to push.  Needing --new is not unusual; for example, it is frequently needed for uploading to Debian experimental.
pt: O pacote é, ou pode ser, novo nesta suite.  Sem isto, o dgit vai recusar o push.  Precisar de --new não é fora do normal; por exemplo, é frequentemente necessário para enviar para Debian experimental.

note: type: Plain text
en: Note that dgit may be unable to access the git history for an entirely new package which has not been accepted by the archive.  So for an entirely new package you need to properly coordinate with anyone else who might upload.
pt: Note que o dgit pode ser incapaz de aceder ao histórico git para um pacote completamente novo que não foi aceite pelo arquivo.  Assim para um pacote completamente novo você precisa de coordenar apropriadamente com qualquer outra pessoa que possa enviar.

note: type: Plain text
en: Do not complain if the working tree does not match your git HEAD, and when building, include the changes from your working tree.  This can be useful with build, if you plan to commit later.  (dgit push will still ensure that the .dsc you upload and the git tree you push are identical, so this option won't make broken pushes.)
pt: Não se queixa se a árvore de trabalho não corresponder ao seu CABEÇALHO git, e ao compilar, inclui as alterações a partir da árvore de trabalho.  Isto pode ser útil com compilação, se planear cometer mais tarde.  (o dgit push irá ainda assegurar que o .dsc você envia e a árvore git que empurra são idênticos, assim esta opção não vai fazer pushes quebrados.)

note: type: Plain text
en: Note that this does B<not> prevent dgit from cleaning your tree, so if the changes in your working tree are in the form of untracked files, those might still be deleted, especially with --clean=git.  If you want to include untracked files in the build, you can use --clean=none or --clean=dpkg-source[-d] in addition to --include-dirty.  Note that this combination can fail if the untracked files are under I<debian/patches/>.
pt: Note que isto B<não> previne o dgit de limpar a sua árvore, assim se as alterações na sua árvore de trabalho estiverem na forma de ficheiros não seguidos, esses ainda podem ser apagados, especialmente com --clean=git.  Se você quer incluir ficheiros não seguidos na compilação, pode usar --clean=none ou --clean=dpkg-source[-d] adicionalmente a --include-dirty.  Note que esta combinação pode falhar se os ficheiros não seguidos estiverem sob I<debian/patches/>.

note: type: Plain text
en: Deprecated alias for --include-dirty.
pt: Nome alternativo descontinuado para --include-dirty.

note: type: Plain text
en: Make B<dgit push>, behave more suitably for collaborating (using shared git history)  with git-using co-developers who aren't using dgit.
pt: Faz o B<dgit push> comportar-se mais apropriadamente para colaboração (usando histórico git partilhado) com co-desenvolvedores que usam git e não usam dgit.

note: type: Plain text
en: With this option, dgit won't mind that the git history you're using isn't necessarily fast forward from the dgit view; instead, it will rely on the changelog to prevent accidentally overwriting changes.
pt: Com esta opção, o dgit não se importa que o histórico git que você está a usar não seja necessariamente de avanço rápido a partir da vista dgit; em vez disso, vai confiar no registo de alterações para prevenir alterações acidentais que sobrescrevem.

note: type: Plain text
en: And, the synthetic commits needed to make the dgit git history fast forward will appear only on the dgit git server, and local dgit suite branches, not on your own main branch.  So they won't end up in the maintainer-visible history, when you push your own branch to make a merge request.
pt: E, os cometidos sintéticos precisos para tornar o histórico git do dgit de avanço rápido irão aparecer apenas no servidor git do dgit, e em ramos da suite dgit locais, não no seu próprio ramo principal.  Assim eles não irão acabar no histórico visível ao maintainer, quando você empurra o seu próprio ramo para fazer um pedido de fusão.

note: type: Plain text
en: This is equivalent to B<--split-view=always --trust-changelog>.
pt: Isto é equivalente a B<--split-view=always --trust-changelog>.

note: type: Plain text
en: Declare that your HEAD really does contain all the (wanted) changes from all versions listed in its changelog; or, all (wanted) changes from I<previous-version>.  This promise is needed when your git branch is not a descendant of the version in the archive according to the git revision history.
pt: Declara que o seu CABEÇALHO realmente contém todas as (necessárias) alterações de todas as versões listadas no seu registo de alterações; ou, todas as (necessárias) alterações a partir de I<previous-version>.  Esta promessa é necessária quando o seu ramo git não é um descendente da versão no arquivo de acordo com o histórico de revisão git.

note: type: Plain text
en: It is safer to specify B<--trust-changelog>, than B<--overwrite=>I<previous-version>, and usually the latter is not needed.
pt: É mais seguro especificar B<--trust-changelog>, que B<--overwrite=>I<previous-version>, e geralmente a segunda não é necessária.

note: type: Plain text
en: B<--trust-changelog> is useful if you are the maintainer, and you have incorporated NMU changes into your own git workflow in a way that doesn't make your branch a fast forward from the NMU.  It can also be useful when there was an upload made without dgit since the most recent upload made with dgit.
pt: B<--trust-changelog> é útil se você for o maintainer, e incorporou alterações NMU no seu próprio fluxo de trabalho git num modo que não torna o seu ramo de avanço rápido a partir do NMU.  Também pode ser útil quando existiu um envio feito sem dgit desde o envio mais recente feito com o dgit.

note: type: Plain text
en: It is also usually necessary the first time a package is pushed with dgit push to a particular suite.  See B<dgit-maint->I<*>B<(7)>.
pt: É também geralmente necessário a primeira vez que um pacote é empurrado com dgit push para uma suite particular. Veja B<dgit-maint->I<*>B<(7)>.

note: type: Plain text
en: With B<--trust-changelog> dgit will check that the version in the archive is mentioned in your debian/changelog.  (This will avoid losing changes, unless someone committed to git a finalised changelog entry, and then made later changes to that version.)
pt: Com B<--trust-changelog> o dgit vai verificar que a versão no arquivo é mencionada no seu debian/changelog.  (Isto vai evitar perder alterações, a menos que alguém tenha cometido para git uma entrada finalizada no registo de alterações, e depois mais tarde feito alterações nessa versão.)

note: type: Plain text
en: With B<--overwrite=>I<previous-version> that version ought to be the version currently in the archive, and it will be unconditionally overwritten, regardless of what's in the changelog.
pt: Com B<--overwrite=>I<previous-version> essa versão deveria ser a versão atualmente no arquivo, e será incondicionalmente sobrescrita, independentemente do que está no registo de alterações.

note: type: Plain text
en: These options will, if necessary, make a pseudo-merge (that is, something that looks like the result of git merge -s ours) to stitch the archive's version into your own git history, so that your push is a fast forward from the archive.
pt: Estas opções irão, se necessário, fazer uma pseudo-fusão (isto é, algo que se parece com o resultado de git merge -s ours) para coser a versão do arquivo no seu próprio histórico git, para que o seu empurrar seja de avanço rápido a partir do arquivo.

note: type: Plain text
en: (In quilt mode B<gbp>, B<dpm>, B<unpatched> or B<baredebian>*, implying a split between the dgit view and the maintainer view, the pseudo-merge will appear only in the dgit view; B<--split-view=always> can be used to force that behaviour, e.g. in other quilt modes.)
pt: (Em modo quilt B<gbp>, B<dpm>, B<unpatched> ou B<baredebian>*, implicar uma divisão entre a vista dgit e a vista de maintainer, a pseudo-fusão irá aparecer apenas na vista do dgit; pode ser usado B<--split-view=always> para forçar esse comportamento, por exemplo, em outros modos quilt.)

note: type: Plain text
en: B<--overwrite> without a version number is an obsolete way of specifying B<--trust-changelog>.
pt: B<--overwrite> sem um número de versão é uma maneira obsoleta de especificar B<--trust-changelog>.

note: type: TP
en: B<--delayed>=I<days>
pt: B<--delayed>=I<dias>

note: type: Plain text
en: Upload to a DELAYED queue.
pt: Envia para uma fila de espera ATRASADA.

note: type: Plain text
en: B<WARNING:> If the maintainer responds by cancelling your upload from the queue, and does not make an upload of their own, this will not rewind the git branch on the dgit git server.  Other dgit users will then see your push (with a warning message from dgit)  even though the maintainer wanted to abolish it.  Such users might unwittingly reintroduce your changes.
pt: B<AVISO:> Se o maintainer responder cancelando o seu envio da fila, e não fizer um envio ele próprio, isto não irá retroceder o ramo git no servidor git do dgit.  Os outros utilizadores do dgit irão ver o seu push (com uma mensagem de aviso do dgit) mesmo que o maintainer tenha querido aboli-lo.  Tais utilizadores podem reintroduzir as suas alterações sem o quererem.

note: type: Plain text
en: If this situation arises, someone should make a suitable dgit push to update the contents of dgit-repos to a version without the controversial changes.
pt: Se esta situação surgir, alguém deve fazer um dgit push apropriado para atualizar o conteúdo de dgit-repos para uma versão sem as alterações controversas.

note: type: Plain text
en: Tells dgit not to look online for additional git repositories containing information about a particular .dsc being imported.  Chasing is the default.
pt: Diz ao dgit para não procurar online por repositórios git adicionais que contenham informação sobre um .dsc particular a ser importado.  A predefinição é perseguir.

note: type: Plain text
en: For most operations (such as fetch and pull), disabling chasing means dgit will access only the git server for the distro you are directly working with, even if the .dsc was copied verbatim from another distro.  For import-dsc, disabling chasing means dgit will work completely offline.
pt: Para a maioria das operações (como fetch e pull), desativar a perseguição significa que o dgit irá aceder apenas ao servidor git para a distribuição que você está a trabalhar diretamente, mesmo que o .dsc tenha sido copiado literalmente a partir de outra distribuição.  Para import-dsc, desativar a perseguição significa que o dgit vai trabalhar completamente offline.

note: type: Plain text
en: Disabling chasing can be hazardous: if the .dsc names a git commit which has been rewritten by those in charge of the distro, this option may prevent that rewrite from being effective.  Also, it can mean that dgit fails to find necessary git commits.
pt: Desativar a perseguição pode ser perigoso: se o .dsc nomear um cometido git que foi rescrito por quem está encarregue da distribuição, esta opção pode impedir esse rescrever de ser efetivo.  Também, pode significar que o dgit falha ao encontrar os cometidos git necessários.

note: type: Plain text
en: Specifies that when split view is in operation, and dgit calculates (or looks up in its cache)  a dgit view corresponding to your HEAD, the dgit view will be left in I<ref>.  The specified ref is unconditionally overwritten, so don't specify a branch you want to keep.
pt: Especifica que a vista dividida está em operação, e o dgit calcula (ou procura na sua cache) uma vista dgit que corresponde ao seu CABEÇALHO. a vista dgit será deixada em I<ref>.  O ref especificado é sobrescrito incondicionalmente, portanto não especifique um ramo que deseja manter.

note: type: Plain text
en: This option is effective only with the following operations: quilt-fixup; push; all builds.  And it is only effective when split view is actually in operation.
pt: Esta opção é efetiva apenas com as seguintes operações: quilt-fixup; push; todas as compilações.  E só é efetiva quando a vista dividida está realmente em operação.

note: type: Plain text
en: If ref does not start with refs/ it is taken to be a branch - i.e. refs/heads/ is prepended.
pt: Se ref não começar com refs/ é tomado como sendo um ramo - isto é, é anteposto refs/heads/.

note: type: Plain text
en: B<--dgit-view-save> is a deprecated alias for --save-dgit-view.
pt: B<--dgit-view-save> é um nome alternativo descontinuado para --save-dgit-view.

note: type: TP
en: B<--deliberately->I<something>
pt: B<--deliberately->I<algo>

note: type: Plain text
en: Declare that you are deliberately doing I<something>.  This can be used to override safety catches, including safety catches which relate to distro-specific policies.  The use of --deliberately is declared and published in the signed tags generated for you by dgit, so that the archive software can give effect to your intent, and for the benefit of humans looking at the history.  The meanings of I<something>s understood in the context of Debian are discussed below:
pt: Declara que você está deliberadamente a fazer I<algo>.  Isto pode ser usado para sobrepor travas de segurança, incluindo travas de segurança que se relacionam com políticas específicas da distribuição.  O uso de --deliberately é declarado e publicado nas etiquetas assinadas geradas para si pelo dgit, para que o software do arquivo possa dar efeito à sua intenção, e para o benefício de humanos a olhar para o histórico.  Os significados da compreensão de I<algo> no contexto de Debian estão discutidos em baixo:

note: type: Plain text
en: Declare that you are deliberately rewriting history.  This could be because your branch is not fast forward from the dgit server history, or not fast forward from a locally-synthesised dsc import.
pt: Declara que você está deliberadamente a rescrever o histórico.  Isto pode acontecer porque o seu ramo não é de avanço rápido a partir do histórico do servidor dgit, ou não de avanço rápido a partir de uma importação dsc sintetizada localmente.

note: type: Plain text
en: When pushing to Debian, use this only when you are making a renewed upload of an entirely new source package whose previous version was not accepted for release from NEW because of problems with copyright or redistributibility; or, exceptionally, for the very first upload with dgit.
pt: Quando empurrar para Debian, use isto apenas quando está a fazer um envio renovado de um pacote fonte completamente novo cuja versão anterior não foi aceite para lançamento de NOVO devido a problemas com direitos de cópia ou redistribuição; ou, excecionalmente, para o mesmo primeiro envio feito com dgit.

note: type: Plain text
en: When split view is in operation, this also prevents the construction by dgit of a pseudomerge to make the dgit view fast forwarding.  Normally only one of --trust-changelog (which creates a suitable pseudomerge)  and --deliberately-not-fast-forward (which suppresses the pseudomerge and the fast forward checks)  should be needed; --trust-changelog is usually better.
pt: Quando a vista dividida está em operação, também previne a construção pelo dgit de uma pseudo-fusão para tornar a vista dgit de avanço rápido.  Normalmente apenas um de --trust-changelog (o qual cria uma pseudo-fusão apropriada) e --deliberately-not-fast-forward (o qual suprime a pseudo-fusão e as verificações de avanço rápido) deve ser necessário; --trust-changelog é geralmente melhor.

note: type: Plain text
en: Declare that you are deliberately including, in the git history of your current push, history which contains a previously-submitted version of this package which was not approved (or has not yet been approved) by the ftpmasters.  When pushing to Debian, only use this option after verifying that: none of the rejected-from-NEW (or never-accepted) versions in the git history of your current push, were rejected by ftpmaster for copyright or redistributability reasons.
pt: Declara que você está deliberadamente a incluir, no histórico git do seu empurrar atual, história que contém uma versão anteriormente cometida deste pacote a qual não foi aprovada (ou ainda não foi aprovada) pelos mestres de ftp.  Ao empurrar para Debian, apenas use esta opção após verificar isto: nenhuma das versões rejeitadas-a-partir-de-NOVO (ou nunca-aceites) no histórico git do seu empurrar atual, foram rejeitadas pelo mestre de ftp por razões de direitos de cópia e redistribuição.

note: type: Plain text
en: Declare that you are deliberately rewriting history and want to throw away the existing repo.  Not relevant when pushing to Debian, as the Debian server will do this automatically when necessary.
pt: Declara que você está deliberadamente a rescrever o histórico e quer descartar o repositório existente.  Não relevante ao empurrar para Debian, pois o servidor Debian irá fazer isto automaticamente quando necessário.

note: type: Plain text
en: With format `3.0 (quilt)', insist on a linear patch stack: one new patch for each relevant commit.  If such a stack cannot be generated, fail.  This is the default for Debian.
pt: Com formato `3.0 (quilt)', insiste numa pilha de patch linear: uma nova patch para cada cometido relevante.  Se tal pilha não puder ser gerada, falha.  Esta é a predefinição para Debian.

note: type: Plain text
en: HEAD should be a series of plain commits (not touching debian/patches/), and pseudomerges, with as ancestor a patches-applied branch.
pt: CABEÇALHO deve ser uma série de cometidos simples (que não tocam em debian/patches/), e pseudo-fusões, tendo como antepassado um ramo de patches aplicadas.

note: type: Plain text
en: With format `3.0 (quilt)', prefer a linear patch stack (as with --quilt=linear)  but if that doesn't seem possible, try to generate a single squashed patch for all the changes made in git (as with --quilt=smash).  This is not a good idea for an NMU in Debian.
pt: Com formato `3.0 (quilt)', prefere uma pilha de patch linear (tal como com --quilt=linear)  mas se isso não for possível, tenta gerar uma única patch esmagada com todas as alterações feitas em git (como com --quilt=smash).  Isto não é uma boa ideia para um NMU em Debian.

note: type: Plain text
en: With format `3.0 (quilt)', assume patches-applied (as obtained from dgit clone) and generate a single additional patch for all the changes made in git.  This is not a good idea for an NMU in Debian.
pt: Com formato `3.0 (quilt)', assume patches aplicadas (como obtido a partir de dgit clone) e gera uma patch adicional única para todas as alterações feitas em git.  Isto não é uma boa ideia para um NMU em Debian.

note: type: Plain text
en: (If HEAD has any in-tree patches already, they must apply cleanly.  This will be the case for any trees produced by dgit fetch or clone; if you do not change the upstream version nor make changes in debian/patches, it will remain true.)
pt: (Se CABEÇALHO já tiver quaisquer patches em-árvore, elas têm de aplicar de forma limpa.  Isto será o caso para quaisquer árvores produzidas por dgit fetch ou clone; se você não alterar a versão de autor nem fizer alterações em debian/patches, irá permanecer verdadeiro.

note: type: Plain text
en: With format `3.0 (quilt)', assume patches-applied (as obtained from dgit clone), delete all the existing patches, and then generate a single patch for all the changes made in git.  This is not a good idea for an NMU in Debian.
pt: Com formato `3.0 (quilt)', assume patches aplicadas (como obtido a partir de dgit clone), apaga todas as patches existentes, e depois gera uma patch única para todas as alterações feitas em git.  Isto não é uma boa ideia para um NMU em Debian.

note: type: Plain text
en: Use this instead of the B<single-debian-patch> dpkg-source format option.  That dpkg-source option cannot handle certain changes to the tree that dpkg-source otherwise permits, and in some cases it can generate strange source packages that dpkg-source appears to accept but which become corrupted when people later try to modify them.
pt: Use isto em vez da opção de formato dpkg-source B<single-debian-patch>.  Essa opção do dpkg-source não consegue lidar com certas alterações na árvore que o dpkg-source caso contrário permite, e nalguns casos pode gerar pacotes fonte estranhos que o dpkg-source parece aceitar mas que tornam-se corrompidos quando mais tarde pessoas tentam modifica-los.

note: type: Plain text
en: With format `3.0 (quilt)', assume patches-applied (as obtained from dgit clone), and check that the patch metadata is up to date.  If it isn't, fail; you must then fix the metadata yourself somehow before pushing.  (NB that dpkg-source --commit will not work because the dgit git tree does not have a B<.pc> directory.)
pt: Com formato `3.0 (quilt)', assume patches aplicadas (como obtido a partir de dgit clone), e verifica se os metadados da patch estão atualizados.  Se não estiverem, falha; você próprio tem então de corrigir os metadados de algum modo antes de empurrar.  (Note bem que dpkg-source --commit não vai funcionar porque a árvore git do dgit não tem um directório B<.pc>.)

note: type: Plain text
en: With format `3.0 (quilt)', assume that the tree is patches-applied (as obtained from dgit clone), and I<assume> that the patch metadata is up to date.  If you use this option and the patch metadata is out of date, dgit push will fail.
pt: Com formato `3.0 (quilt)', assume que a árvore é patches aplicadas (como obtido a partir de dgit clone), e I<assume> que os metadados da patch estão atualizados.  Se você usar esta opção e os metadados da patch estiverem desatualizados, o dgit push vai falhar.

note: type: Plain text
en: Tell dgit that you are using a nearly-dgit-compatible git branch, aka a B<maintainer view>, and do not want your branch changed by dgit.
pt: Diz ao dgit que você está a usar um ramo git quase-compatível-com-dgit, também conhecido por B<vista de maintainer>, e não quer o seu ramo alterado pelo dgit.

note: type: Plain text
en: These quilt modes are known as B<splitting quilt modes>.  See --split-view, below.
pt: Estes modos quilt são conhecidos por B<modos quilt de divisão>.  Veja --split-view, em baixo.

note: type: Plain text
en: B<--gbp> (short for B<--quilt=gbp>)  is for use with git-buildpackage.  Your HEAD is expected to be a patches-unapplied git branch, except that it might contain changes to upstream .gitignore files.  This is the default for dgit gbp-build.
pt: B<--gbp> (curto para B<--quilt=gbp>)  é para usar com git-buildpackage.  Espera-se que o seu CABEÇALHO seja um ramo git de patches não aplicadas, excepto que pode conter alterações aos ficheiros .gitignore do autor.  Esta é a predefinição para dgit gbp-build.

note: type: Plain text
en: B<--dpm> (short for B<--quilt=dpm>)  is for use with git-dpm.  Your HEAD is expected to be a patches-applied git branch, except that it might contain changes to upstream .gitignore files.
pt: B<--dpm> (curto para B<--quilt=dpm>)  é para usar com git-dpm.  Espera-se que o seu CABEÇALHO seja um ramo git de patches aplicadas, excepto que pode conter alterações aos ficheiros .gitignore do autor.

note: type: Plain text
en: B<--quilt=unapplied> specifies that your HEAD is a patches-unapplied git branch (and that any changes to upstream .gitignore files are represented as patches in debian/patches).
pt: B<--quilt=unapplied> especifica que o seu CABEÇALHO é um ramo git de patches não aplicadas (e que quaisquer alterações aos ficheiros .gitignore do autor são representados como patches em debian/patches).

note: type: Plain text
en: B<--quilt=baredebian> (or its alias B<--quilt=baredebian+git>)  specifies that your HEAD contains only a debian/ directory, with any changes to upstream files represented as patches in debian/patches.  The upstream source must be available in git, by default, in a suitably named git tag; see --upstream-commitish.  In this mode, dgit cannot check that all edited upstream files are properly represented as patches: dgit relies on debian/patches being correct.
pt: B<--quilt=baredebian> (ou o seu nome alternativo B<--quilt=baredebian+git>) especifica que o seu CABEÇALHO contém apenas um directório debian/, com quaisquer aos ficheiros do autor representados como patches em debian/patches.  A fonte do autor tem de estar disponível em git, por predefinição, numa etiqueta git com nome apropriado; veja --upstream-commitish.  Neste modo, o dgit não pode verificar que todos os ficheiros de autor editados estão representados apropriadamente como patches: o dgit confia que debian/patches esteja correto.

note: type: Plain text
en: B<--quilt=baredebian+tarball> is like --quilt=baredebian, but is used when there is no appropriate upstream git history.  To construct the dgit view, dgit will import your orig tarballs' contents into git.  In this mode, dgit cannot check that the upstream parts of your upload correspond to what you intend: dgit relies on the right orig tarball(s) existing, and debian/patches being correct.
pt: B<--quilt=baredebian+tarball> é como --quilt=baredebian, mas é usado quando não há um histórico git apropriado.  Para construir a vista dgit, o dgit vai importar o conteúdo dos seus tarballs de origem para git.  Neste modo, o dgit não pode verificar que as partes de autor do seu envio correspondem ao que você pretende: o dgit depende da existência dos tarballs de origem corretos , e que debian/patches esteja correto.

note: type: Plain text
en: With --quilt=gbp|dpm|unapplied|baredebian*, dgit push (or precursors like quilt-fixup and build) will automatically generate a conversion of your git branch into the right form.  dgit push will push the dgit-compatible form (the B<dgit view>)  to the dgit git server.  The dgit view will be visible to you in the dgit remote tracking branches, but your own branch will not be modified.  dgit push will create a tag B<debian/>I<version> for the maintainer view, and the dgit tag B<archive/debian/>I<version> for the dgit view.  dgit quilt-fixup will merely do some checks, and cache the maintainer view.
pt: Com --quilt=gbp|dpm|unapplied|baredebian*, o dgit push (ou precursores como quilt-fixup e build) vão automaticamente gerar uma conversão do seu ramo git para o formato correto.  O dgit push vai empurrar o formato compatível com dgit (a B<vista dgit>) para o servidor git do dgit.  A vista dgit irá ficar visível para si nos ramos de acompanhamento remoto do dgit, mas o seu próprio ramo não será modificado.  O dgit push vai criar a etiqueta B<debian/>I<versão> para a vista de maintainer, e a etiqueta dgit B<archive/debian/>I<versão> para a vista dgit.  O dgit quilt-fixup vai meramente fazer algumas verificações, e meter em cache a vista do maintainer.

note: type: Plain text
en: B<If you have a branch like this it is essential to specify the appropriate --quilt= option!> This is because it is not always possible to tell: a patches-unapplied git branch of a package with one patch, for example, looks very like a patches-applied branch where the user has used git revert to undo the patch, expecting to actually revert it.  However, if you fail to specify the right --quilt option, and you aren't too lucky, dgit will notice the problem and stop, with a useful hint.
pt: B<Se você tem um ramo como este é essencial especificar a opção --quilt= apropriada!> Isto porque nem sempre é possível distinguir: por exemplo, um ramo git de patches não aplicadas de um pacote com uma patch, parece-se muito com um ramo de patches aplicadas onde o utilizador tem usado reversão git para desfazer a patch, esperando que realmente e reverta.  No entanto, se você falhar ao especificar a opção --quilt certa, e não estiver com muita sorte, o dgit vai reparar no problema e parar, com uma dica útil.

note: type: Plain text
en: Specifies that the suite to be operated on is part of distro I<distro>.  This overrides the default value found from the git config option B<dgit-suite.>I<suite>B<.distro>.  The only effect is that other configuration variables (used for accessing the archive and dgit-repos) used are B<dgit-distro.>I<distro>B<.*>.
pt: Especifica que a suite aonde operar faz parte da distribuição I<distro>.  Isto sobrepõe o valor predefinido encontrado a partir da opção de configuração git B<dgit-suite.>I<suite>B<.distro>.  O único efeito é que outras variáveis de configuração (usadas para acesso ao arquivo e repositório dgit) usadas são B<dgit-distro.>I<distro>B<.*>.

note: type: Plain text
en: If your suite is part of a distro that dgit already knows about, you can use this option to make dgit work even if your dgit doesn't know about the suite.  For example, specifying B<-ddebian> will work when the suite is an unknown suite in the Debian archive.
pt: Se a sua suite faz parte duma distribuição que o dgit já conhece, você pode usar esta opção para fazer o dgit funcionar mesmo que o seu dgit não conheça a suite.  Por exemplo, especificar B<-ddebian> irá funcionar quando a suite é uma suite desconhecida no arquivo Debian.

note: type: Plain text
en: To define a new distro it is necessary to define methods and URLs for fetching (and, for dgit push, altering) a variety of information both in the archive and in dgit-repos.  How to set this up is not yet documented.
pt: Para definir uma nova distribuição é necessário definir métodos e URLs para a obter (e, para o dgit push, alterar) uma variedade de informação ambos para o arquivo e o repositório dgit.  Como definir isto ainda não está documentado.

note: type: Plain text
en: Controls whether dgit operates a split view, separating your own branch (as Debian maintainer)  from that shown to users of dgit clone and dgit fetch.
pt: Controla se o dgit opera uma vista dividida, separando o seu próprio ramo (como maintainer Debian)  daquele mostrado aos utilizadores de dgit clone e dgit fetch.

note: type: Plain text
en: When split view is in operation dgit will not make or merge any commits onto your own branch.  Specifically, only the dgit view will contain dgit's pseudomerges, which bring into the git history previous uploads made with dgit push, and any commits in debian/patches required to make a correct `3.0 (quilt)' source package.
pt: Quando a vista dividida está em operação o dgit não vai fazer nem fundir nenhuns cometidos para o seu próprio ramo.  Especificamente, apenas a vista dgit irá conter pseudo-fusões do dgit, que trazem para o histórico git envios anteriores feitos com dgit push, e quaisquer cometidos em debian/patches requeridos para fazer um pacote fonte `3.0 (quilt)' correto.

note: type: Plain text
en: B<auto> is the default, and splits the view only when needed: i.e., when you are working with a `3.0 (quilt)' source package and a splitting quilt mode: --[quilt=]gbp, dpm, unpatched or baredebian*.
pt: B<auto> é a predefinição, e divide a vista apenas quando é necessário: isto é, quando você está a trabalhar com um pacote fonte `3.0 (quilt)' e um modo quilt de divisão: --[quilt=]gbp, dpm, unpatched ou baredebian*.

note: type: Plain text
en: B<always> splits the view regardless of the source format and the quilt mode.
pt: B<always> divide a vista independentemente do formato da fonte e do modo quilt.

note: type: Plain text
en: B<never> will cause dgit to fail if split view is needed.
pt: B<never> irá fazer o dgit falhar se a vista dividida for necessária.

note: type: Plain text
en: When split view is in operation, the dgit view is visible in your local git clone, but only in refs specific to dgit: notably B<remotes/dgit/dgit/>I<suite> and B<archive/>I<distro>B</>I<version>.
pt: Quando a vista dividida está em operação, a vista dgit é visível no seu clone git local, mas apenas em refs específicos para dgit: notavelmente B<remotes/dgit/dgit/>I<suite> e B<archive/>I<distro>B</>I<versão>.

note: type: Plain text
en: Note that split view does not affect dgit fetch, and is not compatible with dgit pull.
pt: Note que a vista dividida não afeta o dgit fetch, e não é compatível com dgit pull.

note: type: Plain text
en: Specifies the .changes file which is to be uploaded.  By default dgit push looks for a single .changes file in the parent directory whose filename suggests it is for the right package and version.
pt: Especifica o ficheiro .changes que é para ser enviado.  Por predefinição o dgit push procura um único ficheiro .changes no directório pai cujo nome de ficheiro sugere que é para o pacote e versão corretos.

note: type: Plain text
en: If the specified I<changesfile> pathname contains slashes, the directory part is also used as the value for B<--build-products-dir>; otherwise, the changes file is expected in that directory (by default, in B<..>).
pt: Se o nome de caminho do I<changesfile> especificado conter barras, a parte de directório é também usada como o valor para B<--build-products-dir>; caso contrário, o ficheiro de alterações é esperado nesse directório (por predefinição, em B<..>).

note: type: Plain text
en: For use with --quilt=baredebian only.  Specifies the commit containing the upstream source.  This commit must be identical to your .orig tarball.  The default is to look for one of the git tags I<U>B< v>I<U>B< upstream/>I<U> (in that order), where U is the upstream version.
pt: Para usar apenas com --quilt=baredebian.  Especifica o cometido que contém a fonte do autor.  Este cometido tem de ser idêntico ao seu tarball .orig.  A predefinição é procurar por uma das etiquetas git I<U>B< v>I<U>B< upstream/>I<U> (por essa ordem), onde U é a versão de autor.

note: type: Plain text
en: When doing a build, delete any changes files matching I<package>B<_>I<version>B<_*.changes> before starting.  This ensures that dgit push (and dgit sbuild) will be able to unambiguously identify the relevant changes files from the most recent build, even if there have been previous builds with different tools or options.  The default is not to remove, but B<--no-rm-old-changes> can be used to override a previous --rm-old-changes or the .rm-old-changes configuration setting.
pt: Ao efetuar uma compilação, apaga quaisquer ficheiros de alterações que correspondam a I<pacote>B<_>I<versão>B<_*.changes> antes de começar.  Isto assegura que o dgit push (e o dgit sbuild) será capaz de identificar de forma inequívoca os ficheiros de alterações relevantes a partir da compilação mais recente, mesmo que tenha havido compilações anteriores com ferramentas ou opções diferentes.  A predefinição é não remover, mas B<--no-rm-old-changes> pode ser usado para sobrepor um --rm-old-changes anterior ou a definição de configuração .rm-old-changes.

note: type: Plain text
en: Note that B<dgit push-source> will always find the right .changes, regardless of this option.
pt: Note que B<dgit push-source> vai sempre encontrar o .changes certo, independentemente desta opção.

note: type: TP
en: B<--build-products-dir=>I<directory>
pt: B<--build-products-dir=>I<directório>

note: type: Plain text
en: Specifies where to find and create tarballs, binary packages, source packages, .changes files, and so on.
pt: Especifica onde procurar e criar tarballs, pacotes binário, pacotes fonte, ficheiros .changes, e mais do mesmo.

note: type: Plain text
en: By default, dgit uses the parent directory (B<..>).
pt: Por predefinição, o dgit usa o directório pai (B<..>).

note: type: Plain text
en: Changing this setting may necessitate moving .orig tarballs to the new directory, so it is probably best to use the B<dgit.default.build-products-dir> configuration setting (see CONFIGURATION, below)  which this command line option overrides).
pt: Modificar esta definição pode necessitar de mover tarballs .orig para o novo directório, assim é provavelmente melhor usar a definição de configuração B<dgit.default.build-products-dir> (veja CONFIGURAÇÃO em baixo)  que esta opção de linha de comandos sobrepõe.

note: type: Plain text
en: Do not delete the destination directory if clone fails.
pt: Não apaga o directório de destino se o clone falhar.

note: type: Plain text
en: Whether to push a DEP-14 tag (eg B<debian/>I<version>)  as well as a dgit tag (eg B<archive/debian/>I<version>).
pt: Se deve-se empurrar uma etiqueta DEP-14 (ex B<debian/>I<versão>)  assim como uma etiqueta dgit (ex B<archive/debian/>I<versão>).

note: type: Plain text
en: Pushing a DEP-14 tag is the default.  In split view mode, a DEP-14 tag is always pushed, regardless of this option.
pt: A predefinição é empurrar uma etiqueta DEP-14.  Em modo de divisão, uma etiqueta DEP-14 é sempre empurrada, independentemente desta opção.

note: type: Plain text
en: B<--always-dep14tag> is an obsolete alias for --dep14tag, retained for compatibility.
pt: B<--always-dep14tag> é um nome alternativo obsoleto para --dep14tag, retido para compatibilidade.

note: type: Plain text
en: Whether to use an existing DEP-14 tag, or make a fresh one.  Ignored if no DEP-14 tag is to be pushed.
pt: Se deve-se usar uma etiqueta DEP-14 existente, ou fazer uma nova.  Ignorado se nenhuma etiqueta DEP-14 vai ser empurrada.

note: type: Plain text
en: Push an existing tag DEP-14 tag.  If there is no existing tag, or the existing tag is unsuitable, fail.
pt: Empurra uma etiqueta DEP-14 existente.  Se não houver uma etiqueta existente, ou a etiqueta existente for inapropriada, falha.

note: type: Plain text
en: Push an existing tag DEP-14 tag, if it exists.  If there is no existing tag, make one.  If there is an existing tag but it is unsuitable, fail.
pt: Empurra uma etiqueta DEP-14, se existir.  Se não houver uma etiqueta existente, cria uma.  Se existir uma etiqueta mas for inapropriada, falha.

note: type: Plain text
en: This is the default.
pt: Isto é a predefinição.

note: type: Plain text
en: Push an existing tag DEP-14 tag, if it exists and is suitable.  If there is no existing tag, or it's unsuitable, make a fresh tag, overwriting the corresponding git ref, and thus deleting any old tag.
pt: Empurra uma etiqueta DEP-14 existente, se existir e for apropriada.  Se não existir uma etiqueta, ou for inapropriada, cria uma nova, sobrescrevendo o ref git correspondente, e assim apagando qualquer etiqueta antiga.

note: type: Plain text
en: Always make a fresh DEP-14 tag, overwriting the corresponding git ref, and thus deleting any old tag.
pt: Cria sempre uma etiqueta DEP-14 nova, sobrescrevendo o ref git correspondente, e assim apagando qualquer etiqueta antiga.

note: type: Plain text
en: This was the default in dgit 11 and earlier.
pt: Isto foi a predefinição no dgit 11 e anteriores.

note: type: Plain text
en: Whether to verify an existing DEP-14 tag, as part of the suitability check.
pt: Se deve-se verificar uma etiqueta DEP-14 existente, como parte da verificação de adequação.

note: type: Plain text
en: The default is to consider an unsigned tag suitable (and not verify a signed one).
pt: A predefinição é considerar uma etiqueta não assinada apropriada (e não verificar uma assinada).

note: type: Plain text
en: Note that any DEP-14 tag being pushed will be, effectively, countersigned: the hash of the DEP-14 tag object (if there is one)  is part of the metadata in the dgit view B<archive/> tag message.
pt: Note que qualquer etiqueta DEP-14 a ser empurrada será, efetivamente, contra assinada: a cinza do objeto etiqueta DEP-14 (se existir uma)  é parte dos metadados na mensagem de etiqueta B<archive/> da vista dgit.

note: type: Plain text
en: Prints debugging information to stderr.  Repeating the option produces more output (currently, up to -DDDD is meaningfully different).
pt: Escreve informação de depuração para o stderr.  Repetir a opção produz mais resultados (atualmente, até -DDDD é significativamente diferente).

note: type: Plain text
en: Controls whether to retain the "playground" working directory B<.git/dgit/unpack> even on success, for examination and debugging.  The default is B<--no-keep-playground> which deletes the directory after a successful execution.
pt: Controla se deve-se reter o directório de trabalho "de brincar" B<.git/dgit/unpack> mesmo em sucesso, para exame e depuração.  A predefinição é B<--no-keep-playground> o que apaga o directório após execução com sucesso.

note: type: TP
en: B<-c>I<name>B<=>I<value>
pt: B<-c>I<nome>B<=>I<valor>

note: type: Plain text
en: Specifies a git configuration option, to be used for this run.  dgit itself is also controlled by git configuration options.
pt: Especifica uma opção de configuração git, para ser usada nesta execução.  O próprio dgit é também controlado por opções de configuração do git.

note: type: TP
en: B<-v>I<version>|B<_> | B<--since-version=>versionI<|>B<_>
pt: B<-v>I<versão>|B<_> | B<--since-version=>versãoI<|>B<_>

note: type: Plain text
en: Specifies the B<-v>I<version> option to pass to dpkg-genchanges, during builds.  Changes (from debian/changelog) since this version will be included in the built changes file, and hence in the upload.  If this option is not specified, dgit will query the archive and use the latest version uploaded to the intended suite.
pt: Especifica a opção B<-v>I<versão> a passar ao dpkg-genchanges, durante compilações.  As alterações (a partir de debian/changelog) desde esta versão serão incluídas no ficheiro de alterações da compilação, e assim no envio.  Se esta opção não for especificada, o dgit vai consultar o arquivo e usar a versão mais recente enviada para a suite destinada.

note: type: Plain text
en: Specifying B<_> inhibits this, so that no -v option will be passed to dpkg-genchanges (and as a result, only the last stanza from debian/changelog will be used for the build and upload).
pt: Especificar B<_> inibe isto, de maneira que nenhuma opção -v será passada ao dpkg-genchanges (e como resultado, apenas a última estrofe de debian/changelog será usada para a compilação e envio).

note: type: Plain text
en: Passed to dpkg-genchanges (eventually).
pt: Passado ao dpkg-genchanges (eventualmente).

note: type: TP
en: B<--ch:>I<option>
pt: B<--ch:>I<opção>

note: type: Plain text
en: Specifies a single additional option to pass, eventually, to dpkg-genchanges.
pt: Especifica uma única opção adicional a passar eventualmente, ao dpkg-genchanges.

note: type: Plain text
en: Options which are safe to pass include B<-C> (and also B<-si -sa -sd> although these should never be necessary with Debian since dgit automatically calculates whether .origs need to be uploaded.)
pt: Opções que são seguras de passar incluem B<-C> (e também B<-si -sa -sd> apesar destas nunca deverem ser necessárias com Debian pois o dgit calcula automaticamente se .origs precisam de ser enviados.)

note: type: Plain text
en: For other options the caveat below applies.
pt: Para outras opções aplica-se o aviso em baixo.

note: type: TP
en: B<--dput:>I<option> | B<--dput:>I<option> |...
pt: B<--dput:>I<opção> | B<--dput:>I<opção> |...

note: type: Plain text
en: Specifies a single additional option to pass to B<curl>, B<dput>, B<debsign>, B<dpkg-source>, B<dpkg-buildpackage>, B<dpkg-genchanges>, B<sbuild>, B<pbuilder>, B<cowbuilder>, B<ssh>, B<dgit>, B<git-debrebase>, B<apt-get>, B<apt-cache>, B<gbp-pq>, B<gbp-build>, or B<mergechanges>.  Can be repeated as necessary.
pt: Especifica uma única opção adicional a passar ao B<curl>, B<dput>, B<debsign>, B<dpkg-source>, B<dpkg-buildpackage>, B<dpkg-genchanges>, B<sbuild>, B<pbuilder>, B<cowbuilder>, B<ssh>, B<dgit>, B<git-debrebase>, B<apt-get>, B<apt-cache>, B<gbp-pq>, B<gbp-build>, ou B<mergechanges>.  Pode ser repetida como necessário.

note: type: Plain text
en: Use of this ability should not normally be necessary.  It is provided for working around bugs, or other unusual situations.  If you use these options, you may violate dgit's assumptions about the behaviour of its subprograms and cause lossage.
pt: O uso desta habilidade não deve normalmente ser necessário.  É fornecido para contornar bugs, ou outras situações não usuais.  Se você usar estas opções, você pode violar as suposições do dgit sobre o comportamento dos seus sub-programas e causar perdas.

note: type: Plain text
en: For dpkg-buildpackage, dpkg-genchanges, mergechanges and sbuild, the option applies only when the program is invoked directly by dgit.  Usually, for passing options to dpkg-genchanges, you should use B<--ch:>I<option>.
pt: Para dpkg-buildpackage, dpkg-genchanges, mergechanges e sbuild, a opção aplica-se apenas quando o programa é invocado diretamente pelo dgit.  Normalmente, para passar opções ao dpkg-genchanges, você deve usar B<--ch:>I<opção>.

note: type: Plain text
en: Specifying --git is not effective for some lower-level read-only git operations performed by dgit, and also not when git is invoked by another program run by dgit.
pt: Especificar --git não é efetivo para algumas operações git de baixo-nível e apenas-leitura efetuadas pelo dgit, e também não é quando o git é invocado por outro programa corrido pelo dgit.

note: type: Plain text
en: B<--curl> options are currently ignored, because dgit uses libcurl rather than curl(1).
pt: As opções B<--curl> são atualmente ignoradas, porque o dgit usa libcurl em vez de curl(1).

note: type: Plain text
en: See notes below regarding ssh and dgit.
pt: Veja as notas em baixo sobre ssh e dgit.

note: type: Plain text
en: NB that --gpg:option is not supported (because debsign does not have that facility).  But see B<-k> and the B<keyid> distro config setting.
pt: Note Bem que --gpg:option não é suportado (porque debsign não tem essa facilidade).  Mas veja B<-k> e a definição de configuração da distribuição B<keyid>.

note: type: TP
en: B<--dput!:>I<option> | B<--dput!:>I<option> |...
pt: B<--dput!:>I<opção> | B<--dput!:>I<opção> |...

note: type: Plain text
en: Specifies an option to remove from the command line for a program called by dgit, as for B<-->I<program>B<:>I<option> (and the same caveats apply).
pt: Especifica uma opção a remover da linha de comandos para um programa chamado pelo dgit, como para B<-->I<programa>B<:>I<opção> (e os mesmos alertas aplicam-se).

note: type: Plain text
en: Any options or arguments exactly identical to I<option> are removed.  (It is not an error if there were none.)
pt: Quaisquer opções ou argumentos exatamente idênticos a I<opção> são removidas.  (Não é um erro se não existirem nenhumas.)

note: type: Plain text
en: This can only be used to delete options which are always passed by default by dgit, or to undo a previous B<-->I<program>B<:>I<option>.  It cannot be used to override option(s) dynamically decided on by dgit.
pt: Isto só pode ser usado para apagar opções que são sempre passadas por predefinição ao dgit, ou para desfazer um B<-->I<programa>B<:>I<opção> anterior.  Não pode ser usado para sobrepor opções decididas dinamicamente pelo dgit.

note: type: TP
en: B<--dput=>I<program> | B<--dput=>I<program> |...
pt: B<--dput=>I<programa> | B<--dput=>I<programa> |...

note: type: Plain text
en: Specifies alternative programs to use instead of B<curl>, B<dput>, B<debsign>, B<dpkg-source>, B<dpkg-buildpackage>, B<dpkg-genbuildinfo>, B<dpkg-genchanges>, B<dpkg-query>, B<sbuild>, B<pbuilder>, B<cowbuilder>, B<gpg>, B<ssh>, B<dgit>, B<git-debrebase>, B<apt-get>, B<apt-cache>, B<git>, B<gbp-pq>, B<gbp-build>, or B<mergechanges>.
pt: Especifica programas alternativos a usar em vez de B<curl>, B<dput>, B<debsign>, B<dpkg-source>, B<dpkg-buildpackage>, B<dpkg-genbuildinfo>, B<dpkg-genchanges>, B<dpkg-query>, B<sbuild>, B<pbuilder>, B<cowbuilder>, B<gpg>, B<ssh>, B<dgit>, B<git-debrebase>, B<apt-get>, B<apt-cache>, B<git>, B<gbp-pq>, B<gbp-build>, ou B<mergechanges>.

note: type: Plain text
en: For B<dpkg-buildpackage>, B<dpkg-genbuildinfo>, B<dpkg-genchanges>, B<dpkg-query>, B<mergechanges> and B<sbuild>, this applies only when the program is invoked directly by dgit.
pt: Para B<dpkg-buildpackage>, B<dpkg-genbuildinfo>, B<dpkg-genchanges>, B<dpkg-query>, B<mergechanges> e B<sbuild>, isto aplica-se apenas quando o programa é invocado diretamente pelo dgit.

note: type: Plain text
en: For B<dgit>, specifies the command to run on the remote host when dgit rpush needs to invoke a remote copy of itself.  (dgit also reinvokes itself as the EDITOR for dpkg-source --commit; this is done using argv[0], and is not affected by --dgit=).
pt: Para B<dgit>, especifica o comando a correr na máquina remota quando o dgit rpush precisa de invocar uma cópia remota dele próprio.  (O dgit também se re-invoca a ele próprio como o EDITOR para dpkg-source --commit; isto é feito usando argv[0], e não é afetado por --dgit=).

note: type: Plain text
en: B<gbp-build>'s value is used instead of gbp build or git-buildpackage.  (The default is the latter unless the former exists on PATH.)  B<gbp-pq>'s value is used instead of gbp pq.  In both cases, unusually, the specified value is split on whitespace to produce a command and possibly some options and/or arguments.
pt: O valor de B<gbp-build> e usado em vez de gbp build ou git-buildpackage.  (A predefinição é último a menos que o anterior exista na PATH.)  O valor de B<gbp-pq> é usado em vez de gbp pq.  Em ambos casos, não usualmente, o valor especificado é dividido no espaço em branco para produzir um comando e possivelmente algumas opções e/ou argumentos.

note: type: Plain text
en: For pbuilder and cowbuilder, the defaults are B<sudo -E pbuilder> and B<sudo -E cowbuilder> respectively.  Like with gbp-build and gbp pq, the specified value is split on whitespace.
pt: Para o pbuilder e cowbuilder, as predefinições são B<sudo -E pbuilder> e B<sudo -E cowbuilder> respetivamente.  Como com gbp-build e gbp pq, o valor especificado é dividido no espaço branco.

note: type: Plain text
en: For B<ssh>, the default value is taken from the B<DGIT_SSH> or B<GIT_SSH> environment variables, if set (see below).  And, for ssh, when accessing the archive and dgit-repos, this command line setting is overridden by the git config variables B<dgit-distro.>I<distro>B<.ssh> and B<.dgit.default.ssh> (which can in turn be overridden with -c).  Also, when dgit is using git to access dgit-repos, only git's idea of what ssh to use (eg, B<GIT_SSH>)  is relevant.
pt: Para B<ssh>, o valor predefinido é tirado das variáveis de ambiente B<DGIT_SSH> ou B<GIT_SSH>, se definidas (veja em baixo).  E, para ssh, quando se acede ao arquivo e repositório dgit, esta definição de linha de comandos é sobreposta pelas variáveis de configuração do git B<dgit-distro.>I<distro>B<.ssh> e B<.dgit.default.ssh> (que por sua vez podem ser sobrepostas com -c).  Também, quando o dgit usa o git para aceder ao repositório dgit, apenas a ideia do git sobre que ssh usar (ex, B<GIT_SSH>)  é relevante.

note: type: TP
en: B<--existing-package=>I<package>
pt: B<--existing-package=>I<pacote>

note: type: Plain text
en: dgit push needs to canonicalise the suite name.  Sometimes, dgit lacks a way to ask the archive to do this without knowing the name of an existing package.  Without --new we can just use the package we are trying to push.  But with --new that will not work, so we guess B<dpkg> or use the value of this option.  This option is not needed with the default mechanisms for accessing the archive.
pt: O dgit push precisa de canonizar o nome da suite.  Por vezes, o dgit não tem maneira de pedir ao arquivo para fazer isto sem saber o nome de um pacote existente.  Sem --new nós podemos apenas usar o pacote que estamos a tentar empurrar.  Mas com --new isso não vai funcionar, então adivinhamos B<dpkg> ou usamos o valor desta opção.  Esta opção não é necessária com os mecanismos predefinidos para se aceder ao arquivo.

note: type: TP
en: B<--initiator-tempdir=>I<directory>
pt: B<--initiator-tempdir=>I<directório>

note: type: Plain text
en: dgit rpush uses a temporary directory on the invoking (signing) host.  This option causes dgit to use I<directory> instead.  Furthermore, the specified directory will be emptied, removed and recreated before dgit starts, rather than removed after dgit finishes.  The directory specified must be an absolute pathname.
pt: O dgit rpush usa um directório temporário na máquina (assinando) que invoca.  Esta opção faz o dgit usar I<directório> em vez disto.  Mais anda, o directório especificado irá ser esvaziado, removido e re-criado antes do dgit começar, em vez de ser removido após o dgit terminar.  O directório especificado tem de ser um nome de caminho absoluto.

note: type: Plain text
en: Go through the motions, fetching all information needed, but do not actually update the output(s).  For push, dgit does the required checks and leaves the new .dsc and .changes in temporary files, but does not sign, tag, push or upload.
pt: Faz todos os movimentos, buscando toda a informação necessária, mas não atualiza realmente os resultados.  Para empurrar, o dgit faz as verificações requeridas e deixa os novos .dsc e .changes em ficheiros temporários, mas não assina, etiqueta, empurra nem envia.

note: type: Plain text
en: This is not a very good simulation.  It can easily go wrong in ways that a for-real push wouldn't.
pt: Isto não é uma simulação muito boa.  Pode facilmente falhar em maneiras que um empurrar real não falharia.

note: type: Plain text
en: Go through many more of the motions: do everything that doesn't involve either signing things, or making changes on the public servers.
pt: Faz muitos mais movimentos: faz tudo que não envolva nem assinar coisas, nem fazer alterações nos servidores públicos.

note: type: Plain text
en: Using this will make unsigned tags, and possibly other local changes, that will get in the way of a for-real push.  So be prepared to burn the version number you're using.
pt: Usar isto irá criar etiquetas não assinadas, e possivelmente outras alterações locais, que irão atrapalhar num empurrar real.  Assim esteja preparado para queimar o número de versão que está a usar.

note: type: TP
en: B<--force->I<something>
pt: B<--force->I<alguma coisa>

note: type: Plain text
en: Instructs dgit to try to proceed despite detecting what it thinks is going to be a fatal problem.  B<This is probably not going to work.> These options are provided as an escape hatch, in case dgit is confused.  (They might also be useful for testing error cases.)
pt: Instrui o dgit para tentar prosseguir apesar da deteção de que ele pensa que vai ser um problema fatal.  B<Isto provavelmente não vai funcionar.> Estas opções são fornecidas como saída de emergência, no caso do dgit estar confuso.  (Também podem ser úteis para casos de teste de erros.)

note: type: Plain text
en: Tell dgit import-dsc to treat a .dsc with a Dgit field like one without it.  The result is a fresh import, discarding the git history that the person who pushed that .dsc was working with.
pt: Diz ao dgit import-dsc para tratar um .dsc com um campo Dgit como sendo um sem ele.  O resultado é um importar fresco, descartando o histórico git em que a pessoa que empurrou esse .dsc estava a trabalhar.

note: type: Plain text
en: Carry on even though this involves reusing a version number of a previous push or upload.  It is normally best to give different versions different numbers.  Some servers (including, usually, the Debian server)  will reject attempts to reuse or replace already-pushed versions.
pt: Continua mesmo que isso envolva reutilizar um número de versão de um empurrar ou envio anterior.  É normalmente melhor dar a diferentes versões diferentes números.  Alguns servidores (incluindo, geralmente, o servidor Debian)  vão rejeitar tentativas de reutilizar ou substituir versões já empurradas.

note: type: Plain text
en: Carry on and upload binaries even though dgit thinks your distro does not permit that.
pt: Continua e envia binários mesmo que o dgit pense que a sua distribuição não permite isso.

note: type: Plain text
en: Carry on and do a source-only upload, without any binaries, even though dgit thinks your distro does not permit that, or does not permit that in this situation.
pt: Continua e faz um envio de apenas-fonte, sem quaisquer binários, mesmo que o dgit pense que a sua distribuição não permite isso, ou não permite isso nesta situação.

note: type: Plain text
en: Carry on even if dgit thinks that your git tree contains changes (relative to your .orig tarballs)  which dpkg-source is not able to represent.  Your build or push will probably fail later.
pt: Continua mesmo que o dgit pense que a sua árvore git contenha alterações (relativas aos seus tarballs .orig)  as quais o dpkg-source não é capaz de representar.  A sua compilação ou empurrar vai provavelmente falhar mais tarde.

note: type: Plain text
en: Use the set of .origs specified in your .changes, exactly, without regard to what is in the archive already.  The archive may well reject your upload.
pt: Usa o conjunto de .origs especificado no seu .changes, exatamente, sem respeitar o que já está no arquivo.  O arquivo pode muito bem rejeitar o seu envio.

note: type: Plain text
en: Carry on despite dgit not understanding your source package format.  dgit will probably mishandle it.
pt: Continua apesar do dgit não compreender o formato do seu pacote fonte.  O dgit vai provavelmente trata-lo de maneira errada.

note: type: Plain text
en: Do not check whether .dsc and .changes match.  The archive will probably reject your upload.
pt: Não verifica se .dsc e .changes correspondem.  O arquivo vai provavelmente rejeitar o seu envio.

note: type: Plain text
en: Force on or off the use of the absurd git-apply emulation when running gbp pq import when importing a package from a .dsc.  See Debian bug #841867.
pt: Força ligar ou desligar do uso da emulação absurda git-apply quando corre gbp pq import ao importar um pacote a partir dum .dsc.  Veja bug Debian #841867.

note: type: Plain text
en: Go ahead and try to push even tainted git objects hat the server says it is going to reject, but without declaring any --deliberately.  This option is provided for testing or strange situations, and is not the way to override the taint check: using it will probably just fail later, burning the version number you are using.  Use the appropriate --deliberately option instead.
pt: Continua e tenta empurrar mesmo que objetos git contaminados fizeram o servidor dizer que vai ser rejeitado, mas sem declarar nenhum --deliberately.  Esta opção é fornecida para testes ou situações estranhas, e não é maneira de sobrepor a verificação de contaminação: usa-la irá provavelmente apenas falhar mais tarde, queimando o número de versão que está a usar.  Use a opção --deliberately apropriada em vez disto.

note: type: Plain text
en: Override the dgit-distro.distro.readonly configuration setting, to specify that we have read/write access and should use the corresponding git and achieve access approach even if the operation is a read-only one.
pt: Sobrepõe a definição de configuração dgit-distro.distro.readonly, para especificar que temos acesso leitura/escrita e deve usar o git correspondente e alcançar abordagem de acesso mesmo que a operação seja uma de só-leitura.

note: type: Plain text
en: Specifies whether to try to obtain missing archive artefacts from the distro's fallback mirror.  (For Debian, the fallback mirror is I<https://incoming.debian.org/debian-buildd/>.)
pt: Especifica se deve-se tentar obter os artefactos do arquivo em falta a partir do espelho de recurso da distribuição.  (Para Debian, o espelho de recurso é I<https://incoming.debian.org/debian-buildd/>.)

note: type: Plain text
en: The default is to try the fallback mirror.
pt: A predefinição é tentar o espelho de recurso.

note: type: Plain text
en: Specifies that the dgit rpush invoking host should be willing to sign only a .dsc or .changes file with target suite I<suite>.
pt: Especifica que a máquina que invoca dgit rpush deve estar disposta a assinar apenas um ficheiro .dsc ou .changes com suite alvo I<suite>.

note: type: TP
en: B<--expect-version>=I<version>
pt: B<--expect-version>=I<versão>

note: type: Plain text
en: Specifies that the dgit rpush invoking host should be willing to sign only a .dsc or .changes file with version I<version>.
pt: Especifica que a máquina que invoca dgit rpush deve estar disposta a assinar apenas um ficheiro .dsc ou .changes com versão I<versão>.

note: type: Plain text
en: These options activate configuration and behavioural changes needed when the tag2upload robot invokes dgit.  They are not intended for users.
pt: Estas opções ativam mudanças de configuração e comportamento necessárias quando o robot tag2upload invoca o dgit.  Elas não são destinadas a utilizadores.

note: type: Plain text
en: Pass --allow-unrelated-histories to git merge command when running dgit pull.  This makes dgit pull easier to use when the main repository has never been used with dgit and hence has unrelated histories.
pt: Passa --allow-unrelated-histories ao comando git merge quando corre dgit pull.  Isto torna o dgit pull mais fácil de usar quando o repositório principal nunca foi usado com dgit e por isso tem históricos não relacionados.

note: type: TP
en: B<--dsc-control-add=>I<FIELD>B<=>I<VALUE>
pt: B<--dsc-control-add=>I<CAMPO>B<=>I<VALOR>

note: type: Plain text
en: Add an additional control file field to the .dsc.
pt: Adiciona um campo adicional de ficheiro controle ao .dsc.

note: type: Plain text
en: This is similar to using B<--dpkg-source:-D>I<FIELD>B<=>I<VALUE> except that (i) you can only add an additional field, not override a value; and (ii) for an rpush, the field is added on the invoking (signing) host, not the build host.
pt: Isto é semelhante a usar B<--dpkg-source:-D>I<CAMPO>B<=>I<VALOR> excepto que (1) você pode apenas adicionar um campo adicional, não sobrepor um valor, e (2) para um rpush, o campo é adicionado na máquina (assinando) que invoca, não na máquina que compila.

note: type: TP
en: B<--ch-control-add=>I<FIELD>B<=>I<VALUE>
pt: B<--ch-control-add=>I<CAMPO>B<=>I<VALOR>

note: type: Plain text
en: Like B<--dsc-control-add> but for adding fields to the .changes file.
pt: Como B<--dsc-control-add> mas +para adicionar campos ao ficheiro .changes.

note: type: SH
en: EXIT STATUS
pt: ESTADO DE SAÍDA

note: type: Plain text
en: Success.
pt: Sucesso.

note: type: Plain text
en: With B<dgit download-unfetched-origs>, the relevant origs were identified, but some of them couldn't be downloaded.
pt: Com B<dgit download-unfetched-origs>, os origs relevantes foram identificados, mas alguns deles não puderam ser descarregados.

note: type: Plain text
en: Source package does not exist in the requested suite.
pt: Pacote fonte não existe na suite requisitada.

note: type: Plain text
en: With B<dgit download-unfetched-origs>, no relevant origs exist in the archive.
pt: Com B<dgit download-unfetched-origs>, nenhuns origs relevantes existem no arquivo.

note: type: Plain text
en: With B<dgit download-unfetched-origs>, the selection of origs in the archive is confusing: multiple files exist (for the same component), so we cannot uniquely identify which to use.
pt: Com B<dgit download-unfetched-origs>, a seleção de origs no arquivo é confusa: existem múltiplos ficheiros (para o mesmo componente), assim não conseguimos identificar exclusivamente qual deles usar.

note: type: Plain text
en: Discrepancy between (generated) source package and git information.  See B<dgit>(7).
pt: Discrepância entre pacote fonte (gerado) e informação git.  Veja B<dgit>(7).

note: type: Plain text
en: When B<dgit build-source> exits with status 6, the source package *has* been built; it just might not be what was intended.
pt: Quando B<dgit build-source> termina com estado 6, o pacote fonte *foi* compilado; apenas pode não ser o que era pretendido.

note: type: Plain text
en: Bad usage.
pt: Má utilização.

note: type: Plain text
en: Invalid configuration.
pt: Configuração inválida.

note: type: TP
en: Other
pt: Outro

note: type: Plain text
en: Catastrophic failure.
pt: Falha catastrófica.

note: type: =head1
en: CONFIGURATION
pt: CONFIGURAÇÃO

note: type: Plain text
en: dgit can be configured via the git config system.  You may set keys with git-config (either in system-global or per-tree configuration), or provide B<-c>I<key>B<=>I<value> on the dgit command line.
pt: O dgit pode ser configurado via sistema de configuração do git.  Você pode definir chaves com git-config (seja configuração global-do-sistema ou por-árvore), ou fornecer B<-c>I<chave>B<=>I<valor> na linha de comandos do dgit.

note: type: Plain text
en: Settings likely to be useful for an end user include:
pt: Definições que deverão ser usadas por utilizador final incluem:

note: type: Plain text
en: Specifies where to find the built files to be uploaded, when --build-products-dir is not specified.  The default is the parent directory (B<..>).
pt: Especifica onde encontrar os ficheiros de compilação para serem enviados, quando, --build-products-dir não é especificado.  A predefinição é o directório pai (B<..>).

note: type: Plain text
en: Specifies the distro for a suite.  dgit keys off the suite name (which appears in changelogs etc.), and uses that to determine the distro which is involved.  The config used is thereafter that for the distro.
pt: Especifica a distribuição para uma suite.  Chaves dgit fora do nome da suite (que aparecem em relatórios de alterações e etc.), e usa isso para determinar a distribuição que está envolvida.  A configuração usada é a partir daí para a distribuição.

note: type: Plain text
en: I<suite> may be a glob pattern.
pt: I<suite> pode ser um padrão global.

note: type: Plain text
en: The default distro for an unknown suite.
pt: A distribuição predefinida para uma suite desconhecida.

note: type: Plain text
en: This is only used if no B</usr/share/distro-info/>I<somedistro>B<.csv> mentions the specified suite.
pt: Isto é usado apenas se nenhum B</usr/share/distro-info/>I<alguma-distribuição>B<.csv> mencionar a suite especificada.

note: type: Plain text
en: The default suite (eg for clone).
pt: A suite predefinida (por exemplo para clone)

note: type: Plain text
en: for each B<dgit-distro.>I<distro>B<.>*, the default value used if there is no distro-specific setting.
pt: Para cada B<dgit-distro.>I<distro>B<.>*, o valor predefinido usado se não existir uma definição específica de distribuição.

note: type: Plain text
en: Whether B<dgit build-source> should check that the resulting source package properly corresponds to the git HEAD.  True by default.  (Correspondence checking cannot be disabled for B<dgit push!>, since that would lead to the publication of broken outputs.)
pt: Se B<dgit build-source> deve verificar que o pacote fonte resultante corresponde apropriadamente ao CABEÇALHO git.  Verdadeiro por predefinição.  (A verificação de correspondência não pode ser desativada para B<dgit push!>, pois isso ia levar à publicação de resultados quebrados.)

note: type: Plain text
en: One of the values for the command line --clean= option; used if --clean is not specified.
pt: Um dos valores para a linha de comandos --clean= opção; usado se --clean não for especificado.

note: type: Plain text
en: Like .clean-mode, but ignored if the value is unknown to this version of dgit.  Setting both .clean-mode and .clean-mode-newer is useful to provide a single git config compatible with different dgit versions.
pt: Como .clean-mode, mas ignorado se o valor for desconhecido para esta versão do dgit.  Definir ambos .clean-mode e .clean-mode-newer é útil para fornecer uma configuração git única compatível com diferentes versões do dgit.

note: type: Plain text
en: One of the values for the command line --quilt= option; used if --quilt is not specified.
pt: Um dos valores para a linha de comandos --quilt= opção; usado se --quilt não for especificado.

note: type: Plain text
en: Boolean, used if neither --rm-old-changes nor --no-rm-old-changes is specified.  The default is not to remove.
pt: Booleano, usado se nem --rm-old-changes nem --no-rm-old-changes for especificado.  A predefinição é não remover.

note: type: Plain text
en: Whether you have push access to the distro.  For Debian, it is OK to use auto, which uses readonly mode if you are not pushing right now; but, setting this to false will avoid relying on the mirror of the dgit git repository server.
pt: Se você tem acesso de empurrar para a distribuição.  Para Debian, é OK usar auto, o que usa modo só-leitura se você não está a empurrar no momento; mas, definir isto para false irá evitar depender do espelho do servidor de repositório git do dgit.

note: type: Plain text
en: See also B<-k>.
pt: Veja também B<-k>.

note: type: Plain text
en: Not relevant for Debian.
pt: Não relevante para Debian.

note: type: Plain text
en: Might be useful if you have an intermediate queue server.
pt: Pode ser útil se você tiver um servidor de fila intermediária.

note: type: Plain text
en: Values to configure for user.name and user.email in new git trees.  If not specified, the DEBFULLNAME and DEBEMAIL environment variables are used, respectively.  Only used if .setup-usermail is not disabled.
pt: Valores a configurar para user.name e user.email em novas árvores git.  Se não especificado, as variáveis de ambiente DEBFULLNAME e DEBEMAIL são usadas, respetivamente.  Apenas usado se .setup-usermail não estiver desativado.

note: type: Plain text
en: Whether to set user.name and user.email in new git trees.  True by default.  Ignored for dgit setup-useremail, which does it anyway.
pt: Se deve-se definir user.name e user.email em novas árvores git.  Verdadeiro por predefinição.  Ignorado para dgit setup-useremail, o que já o faz de qualquer maneira.

note: type: Plain text
en: Whether to set up a merge driver which uses dpkg-mergechangelogs for debian/changelog.  True by default.  Ignored for dgit setup-mergechangelogs, which does it anyway.
pt: Se deve-se configurar um controlador de fusão que usa dpkg-mergechangelogs para debian/changelog.  Verdadeiro por predefinição.  Ignorado para dgit setup-mergechangelogs, o que já o faz de qualquer maneira.

note: type: Plain text
en: Whether to configure .git/info/attributes to suppress checkin/checkout file content transformations in new git trees.  True by default.  Ignored for dgit setup-gitattributes, which does it anyway.
pt: Se deve-se configurar .git/info/attributes para suprimir transformações de conteúdo no ficheiro checkin/checkout em novas árvores git.  Verdadeiro por predefinição.  Ignorado para dgit setup-gitattributes, que já o faz de qualquer maneira.

note: type: Plain text
en: Program to use instead of I<cmd>.  Works like B<-->I<cmd>B<=>... .
pt: Programa a usar em vez de I<cmd>.  Funciona como B<-->I<cmd>B<=>... .

note: type: Plain text
en: Extra options to pass to I<cmd>.  Works like B<-->I<cmd>B<:>... .  To pass several options, configure multiple values in git config (with git config --add).  The options for B<dgit.default.opts->I<cmd> and B<dgit-distro.>I<distro>B</push.opts->I<cmd> are all used, followed by options from dgit's command line.
pt: Opções extra a passar para I<cmd>.  Funciona como B<-->I<cmd>B<:>... .  Para passar várias opções, configure múltiplos valores na configuração do git (com git config --add).  As opções para B<dgit.default.opts->I<cmd> e B<dgit-distro.>I<distro>B</push.opts->I<cmd> são todas usadas, seguidas por opções da linha de comandos do dgit.

note: type: SH
en: ACCESS CONFIGURATION
pt: CONFIGURAÇÃO DE ACESSO

note: type: Plain text
en: There are many other settings which specify how a particular distro's services (archive and git) are provided.  These should not normally be adjusted, but are documented for the benefit of distros who wish to adopt dgit.
pt: Existem muitas outras definições que especificam como os serviços duma distribuição particular (arquivo e git) são fornecidos.  Estes não devem ser normalmente ajustados, mas estão documentados para o benefício das distribuições que desejam adotar o dgit.

note: type: Plain text
en: Shown in git tags, Dgit fields, and so on.
pt: Mostrado em etiquetas git, campos Dgit, e mais do mesmo.

note: type: Plain text
en: Used for all access configuration lookup.
pt: Usado para procura de configuração de acesso total.

note: type: Plain text
en: If set, overrides corresponding non B</push> config when B<readonly=false>, or when pushing and B<readonly=auto>.
pt: Se definido, sobrepõe configuração não B</push> correspondente quando B<readonly=false>, ou quando se empurra e B<readonly=auto>.

note: type: Plain text
en: Controls the behaviour of B<dgit push>.
pt: Controla o comportamento de B<dgit push>.

note: type: SH
en: ENVIRONMENT VARIABLES
pt: VARIÁVEIS DE AMBIENTE

note: type: Plain text
en: specify an alternative default program (and perhaps arguments) to use instead of ssh.  DGIT_SSH is consulted first and may contain arguments; if it contains any whitespace will be passed to the shell.  GIT_SSH specifies just the program; no arguments can be specified, so dgit interprets it the same way as git does.  See also the --ssh= and --ssh: options.
pt: Especifica um programa predefinido alternativo (e talvez argumentos) para usar em vez do ssh.  DGIT_SSH é consultado primeiro e pode conter argumentos; se conter qualquer espaço em branco será passado à shell.  GIT_SSH especifica apenas o programa; nenhum argumento pode ser especificado, assim o dgit interpreta-o do mesmo modo que o git faz.  Veja também as opções --ssh= e --ssh: .

note: type: Plain text
en: Default git user.email and user.name for new trees.  See B<dgit setup-new-tree>.
pt: O utilizador.email git predefinido e utilizador.nome para novas árvores.  Veja B<dgit setup-new-tree>.

note: type: Plain text
en: and other subprograms and modules used by dgit are affected by various environment variables.  Consult the documentation for those programs for details.
pt: e outros subprogramas e módulos usados pelo dgit são afetados por várias variáveis de ambiente.  Consulte a documentação para esses programas para mais detalhes.

note: type: SH
en: SUPPORT ON OLD DISTRIBUTIONS
pt: SUPORTE EM DISTRIBUIÇÕES ANTIGAS

note: type: Plain text
en: We aim to make modern dgit installable and useable on old versions of Debian, and on derivatives.  One reason this is helpful is that it can be necessary to upgrade to handle strange source packages that trigger bugs (in dgit or tools that dgit runs).
pt: Nós visamos fazer o dgit moderno instalável e utilizável em versões antigas de Debian, e nos derivados.  Uma razão onde isto ajuda é que pode ser necessário atualizar para lidar com pacotes fonte estranhos que provocam bugs (no dgit ou em ferramentas que o dgit corre).

note: type: Plain text
en: This version of B<dgit.deb> is directly installable, and functional (with B<apt install dgit.deb>)  all the way back to Debian 10 (buster) and later; this is tested in our CI.  It is likely to work on many Debian derivatives, too.
pt: Esta versão de B<dgit.deb> é diretamente instalável, e funcional (com B<apt install dgit.deb>)  andando para trás até Debian 10 (buster) e posteriores; isto é testado no nosso CI.  É provável que funcione em muitos derivados de Debian também.

note: type: Plain text
en: There should be a `dgit rebase-prep' command or some such to turn a fast-forwarding branch containing pseudo-merges back into a rebasing patch stack.  It might have to leave a note for a future dgit push.
pt: Deverá existir um comando `dgit rebase-prep' ou algo do género para reverter um ramo de avanço rápido contendo pseudo-fusões de volta a uma pilha de patch re-baseada.  Pode ter de deixar uma nota para um dgit push futuro.

note: type: Plain text
en: If the dgit push fails halfway through, it is not necessarily restartable and idempotent.  It would be good to check that the proposed signing key is available before starting work.
pt: Se o dgit push falhar a meio do caminho, não é necessariamente reiniciável e idempotente.  Será bom verificar que a chave de assinatura proposta está disponível antes de começar o trabalho.

note: type: Plain text
en: dgit's build functions, and dgit push, may make changes to your current HEAD.  Sadly this is necessary for packages in the `3.0 (quilt)' source format.  This is ultimately due to what I consider design problems in quilt and dpkg-source.
pt: As funções de compilação do dgit, e o dgit push, podem fazer alterações no seu CABEÇALHO atual.  Infelizmente isto é necessário para pacotes no formato fonte `3.0 (quilt)'.  Isto deve-se ultimamente ao que Eu chamo de problemas de desenho no quilt e no dpkg-source.

note: type: Plain text
en: --dry-run does not always work properly, as not doing some of the git fetches may result in subsequent actions being different.  Doing a non-dry-run dgit fetch first will help.  --damp-run is likely to work much better.
pt: --dry-run nem sempre funciona de modo apropriado, pois não fazer algumas das buscas git pode resultar em ações subsequentes a serem diferentes.  Fazer um dgit fetch non-dry-run primeiro irá ajudar.  --damp-run é provável que funcione muito melhor.

note: type: =head1
en: SEE ALSO
pt: VEJA TAMBÉM
