module.po

# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2001-2025, Python Software Foundation
# This file is distributed under the same license as the Python package.
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
#
# Translators:
# i17obot <i17obot@rougeth.com>, 2021
# Rodrigo C&acirc;ndido, 2022
# Welliton Malta <wellyton47@hotmail.com>, 2023
# Marco Rougeth <marco@rougeth.com>, 2023
# Rafael Fontenelle <rffontenelle@gmail.com>, 2025
#
#, fuzzy
msgid ""
msgstr ""
"Project-Id-Version: Python 3.13\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2025-02-28 14:17+0000\n"
"PO-Revision-Date: 2021-06-28 00:49+0000\n"
"Last-Translator: Rafael Fontenelle <rffontenelle@gmail.com>, 2025\n"
"Language-Team: Portuguese (Brazil) (https://app.transifex.com/python-doc/"
"teams/5390/pt_BR/)\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Language: pt_BR\n"
"Plural-Forms: nplurals=3; plural=(n == 0 || n == 1) ? 0 : n != 0 && n % "
"1000000 == 0 ? 1 : 2;\n"

#: ../../c-api/module.rst:6
msgid "Module Objects"
msgstr "Objetos do M&oacute;dulo"

#: ../../c-api/module.rst:15
msgid ""
"This instance of :c:type:`PyTypeObject` represents the Python module type.  "
"This is exposed to Python programs as ``types.ModuleType``."
msgstr ""
"Esta inst&acirc;ncia de :c:type:`PyTypeObject` representa o tipo de m&oacute;dulo Python. "
"Isso &eacute; exposto a programas Python como ``types.ModuleType``."

#: ../../c-api/module.rst:21
msgid ""
"Return true if *p* is a module object, or a subtype of a module object. This "
"function always succeeds."
msgstr ""
"Retorna true se *p* for um objeto de m&oacute;dulo ou um subtipo de um objeto de "
"m&oacute;dulo. Esta fun&ccedil;&atilde;o sempre &eacute; bem-sucedida."

#: ../../c-api/module.rst:27
msgid ""
"Return true if *p* is a module object, but not a subtype of :c:data:"
"`PyModule_Type`.  This function always succeeds."
msgstr ""
"Retorna true se *p* for um objeto de m&oacute;dulo, mas n&atilde;o um subtipo de :c:data:"
"`PyModule_Type`. Essa fun&ccedil;&atilde;o &eacute; sempre bem-sucedida."

#: ../../c-api/module.rst:40
msgid ""
"Return a new module object with :attr:`module.__name__` set to *name*. The "
"module's :attr:`!__name__`, :attr:`~module.__doc__`, :attr:`~module."
"__package__` and :attr:`~module.__loader__` attributes are filled in (all "
"but :attr:`!__name__` are set to ``None``). The caller is responsible for "
"setting a :attr:`~module.__file__` attribute."
msgstr ""
"Retorna um novo objeto de m&oacute;dulo com :attr:`module.__name__` definido como "
"*name*. Os atributos :attr:`!__name__`, :attr:`~module.__doc__`, :attr:"
"`~module.__package__` e :attr:`~module.__loader__` do m&oacute;dulo s&atilde;o preenchidos "
"(todos, exceto :attr:`!__name__`, s&atilde;o definidos como ``None``). O chamador &eacute; "
"respons&aacute;vel por definir um atributo :attr:`~module.__file__`."

#: ../../c-api/module.rst:46 ../../c-api/module.rst:272
#: ../../c-api/module.rst:474
msgid "Return ``NULL`` with an exception set on error."
msgstr "Retorna ``NULL`` com uma exce&ccedil;&atilde;o definida em caso de erro."

#: ../../c-api/module.rst:50
msgid ""
":attr:`~module.__package__` and :attr:`~module.__loader__` are now set to "
"``None``."
msgstr ""
":attr:`~module.__package__` e :attr:`~module.__loader__` agora est&atilde;o "
"definidos como ``None``."

#: ../../c-api/module.rst:57
msgid ""
"Similar to :c:func:`PyModule_NewObject`, but the name is a UTF-8 encoded "
"string instead of a Unicode object."
msgstr ""
"Semelhante a :c:func:`PyModule_NewObject`, mas o nome &eacute; uma string "
"codificada em UTF-8 em vez de um objeto Unicode."

#: ../../c-api/module.rst:65
msgid ""
"Return the dictionary object that implements *module*'s namespace; this "
"object is the same as the :attr:`~object.__dict__` attribute of the module "
"object. If *module* is not a module object (or a subtype of a module "
"object), :exc:`SystemError` is raised and ``NULL`` is returned."
msgstr ""
"Retorna o objeto dicion&aacute;rio que implementa o espa&ccedil;o de nomes de *module*; "
"este objeto &eacute; o mesmo que o atributo :attr:`~object.__dict__` do objeto de "
"m&oacute;dulo. Se *module* n&atilde;o for um objeto de m&oacute;dulo (ou um subtipo de um objeto "
"de m&oacute;dulo), :exc:`SystemError` &eacute; levantada e ``NULL`` &eacute; retornado."

#: ../../c-api/module.rst:70
msgid ""
"It is recommended extensions use other ``PyModule_*`` and ``PyObject_*`` "
"functions rather than directly manipulate a module's :attr:`~object."
"__dict__`."
msgstr ""
"&Eacute; recomendado que as extens&otilde;es usem outras fun&ccedil;&otilde;es ``PyModule_*`` e "
"``PyObject_*`` em vez de manipular diretamente o :attr:`~object.__dict__` de "
"um m&oacute;dulo."

#: ../../c-api/module.rst:81
msgid ""
"Return *module*'s :attr:`~module.__name__` value.  If the module does not "
"provide one, or if it is not a string, :exc:`SystemError` is raised and "
"``NULL`` is returned."
msgstr ""
"Retorna o valor :attr:`~module.__name__` do *module*. Se o m&oacute;dulo n&atilde;o "
"fornecer um, ou se n&atilde;o for uma string, :exc:`SystemError` &eacute; levantada e "
"``NULL`` &eacute; retornado."

#: ../../c-api/module.rst:90
msgid ""
"Similar to :c:func:`PyModule_GetNameObject` but return the name encoded to "
"``'utf-8'``."
msgstr ""
"Semelhante a :c:func:`PyModule_GetNameObject` mas retorna o nome codificado "
"em ``'utf-8'``"

#: ../../c-api/module.rst:95
msgid ""
"Return the \"state\" of the module, that is, a pointer to the block of "
"memory allocated at module creation time, or ``NULL``.  See :c:member:"
"`PyModuleDef.m_size`."
msgstr ""
"Retorna o \"estado\" do m&oacute;dulo, ou seja, um ponteiro para o bloco de mem&oacute;ria "
"alocado no momento de cria&ccedil;&atilde;o do m&oacute;dulo, ou ``NULL``. Ver :c:member:"
"`PyModuleDef.m_size`."

#: ../../c-api/module.rst:102
msgid ""
"Return a pointer to the :c:type:`PyModuleDef` struct from which the module "
"was created, or ``NULL`` if the module wasn't created from a definition."
msgstr ""
"Retorna um ponteiro para a estrutura :c:type:`PyModuleDef` da qual o m&oacute;dulo "
"foi criado, ou ``NULL`` se o m&oacute;dulo n&atilde;o foi criado de uma defini&ccedil;&atilde;o."

#: ../../c-api/module.rst:112
msgid ""
"Return the name of the file from which *module* was loaded using *module*'s :"
"attr:`~module.__file__` attribute.  If this is not defined, or if it is not "
"a string, raise :exc:`SystemError` and return ``NULL``; otherwise return a "
"reference to a Unicode object."
msgstr ""
"Retorna o nome do arquivo do qual o *module* foi carregado usando o "
"atributo :attr:`~module.__file__` do *module*. Se n&atilde;o estiver definido, ou "
"se n&atilde;o for uma string unicode, levanta :exc:`SystemError` e retorna "
"``NULL``; Caso contr&aacute;rio, retorna uma refer&ecirc;ncia a um objeto Unicode."

#: ../../c-api/module.rst:122
msgid ""
"Similar to :c:func:`PyModule_GetFilenameObject` but return the filename "
"encoded to 'utf-8'."
msgstr ""
"Semelhante a :c:func:`PyModule_GetFilenameObject` mas retorna o nome do "
"arquivo codificado em 'utf-8'."

#: ../../c-api/module.rst:125
msgid ""
":c:func:`PyModule_GetFilename` raises :exc:`UnicodeEncodeError` on "
"unencodable filenames, use :c:func:`PyModule_GetFilenameObject` instead."
msgstr ""
":c:func:`PyModule_GetFilename`: levanta :exc:`UnicodeEncodeError` quando h&aacute; "
"nomes de arquivos n&atilde;o codific&aacute;veis, use :c:func:`PyModule_GetFilenameObject`."

#: ../../c-api/module.rst:133
msgid "Initializing C modules"
msgstr "Inicializando m&oacute;dulos C"

#: ../../c-api/module.rst:135
msgid ""
"Modules objects are usually created from extension modules (shared libraries "
"which export an initialization function), or compiled-in modules (where the "
"initialization function is added using :c:func:`PyImport_AppendInittab`). "
"See :ref:`building` or :ref:`extending-with-embedding` for details."
msgstr ""
"Objetos de m&oacute;dulos s&atilde;o geralmente criados a partir de m&oacute;dulos de extens&atilde;o "
"(bibliotecas compartilhadas que exportam uma fun&ccedil;&atilde;o de inicializa&ccedil;&atilde;o), ou "
"m&oacute;dulos compilados (onde a fun&ccedil;&atilde;o de inicializa&ccedil;&atilde;o &eacute; adicionada usando :c:"
"func:`PyImport_AppendInittab`). Ver :ref:`building` ou :ref:`extending-with-"
"embedding` para mais detalhes."

#: ../../c-api/module.rst:140
msgid ""
"The initialization function can either pass a module definition instance to :"
"c:func:`PyModule_Create`, and return the resulting module object, or request "
"\"multi-phase initialization\" by returning the definition struct itself."
msgstr ""
"A fun&ccedil;&atilde;o de inicializa&ccedil;&atilde;o pode passar uma inst&acirc;ncia de defini&ccedil;&atilde;o de m&oacute;dulo "
"para :c:func:`PyModule_Create` e retornar o objeto de m&oacute;dulo resultante ou "
"solicitar \"inicializa&ccedil;&atilde;o multif&aacute;sica\" retornando a pr&oacute;pria estrutura de "
"defini&ccedil;&atilde;o."

#: ../../c-api/module.rst:146
msgid ""
"The module definition struct, which holds all information needed to create a "
"module object. There is usually only one statically initialized variable of "
"this type for each module."
msgstr ""
"A estrutura de defini&ccedil;&atilde;o de m&oacute;dulo, que cont&eacute;m todas as informa&ccedil;&otilde;es "
"necess&aacute;ria para criar um objeto de m&oacute;dulo. Geralmente, h&aacute; apenas uma "
"vari&aacute;vel inicializada estaticamente desse tipo para cada m&oacute;dulo."

#: ../../c-api/module.rst:152
msgid "Always initialize this member to :c:macro:`PyModuleDef_HEAD_INIT`."
msgstr "Sempre inicializa este membro para :c:macro:`PyModuleDef_HEAD_INIT`."

#: ../../c-api/module.rst:156
msgid "Name for the new module."
msgstr "Nome para o novo m&oacute;dulo."

#: ../../c-api/module.rst:160
msgid ""
"Docstring for the module; usually a docstring variable created with :c:macro:"
"`PyDoc_STRVAR` is used."
msgstr ""
"Docstring para o m&oacute;dulo; geralmente uma vari&aacute;vel docstring criada com :c:"
"macro:`PyDoc_STRVAR` &eacute; usada."

#: ../../c-api/module.rst:165
msgid ""
"Module state may be kept in a per-module memory area that can be retrieved "
"with :c:func:`PyModule_GetState`, rather than in static globals. This makes "
"modules safe for use in multiple sub-interpreters."
msgstr ""
"O estado do m&oacute;dulo pode ser mantido em uma &aacute;rea de mem&oacute;ria por m&oacute;dulo que "
"pode ser recuperada com :c:func:`PyModule_GetState`, em vez de em globais "
"est&aacute;ticos. Isso torna os m&oacute;dulos seguros para uso em v&aacute;rios "
"subinterpretadores."

#: ../../c-api/module.rst:169
msgid ""
"This memory area is allocated based on *m_size* on module creation, and "
"freed when the module object is deallocated, after the :c:member:"
"`~PyModuleDef.m_free` function has been called, if present."
msgstr ""
"Esta &aacute;rea de mem&oacute;ria &eacute; alocada com base em *m_size* na cria&ccedil;&atilde;o do m&oacute;dulo e "
"liberada quando o objeto do m&oacute;dulo &eacute; desalocado, ap&oacute;s a fun&ccedil;&atilde;o :c:member:"
"`~PyModuleDef.m_free` ter sido chamada, se presente."

#: ../../c-api/module.rst:173
msgid ""
"Setting ``m_size`` to ``-1`` means that the module does not support sub-"
"interpreters, because it has global state."
msgstr ""
"Definir ``m_size`` como ``-1`` significa que o m&oacute;dulo n&atilde;o oferece suporte a "
"subinterpretadores, porque ele tem estado global."

#: ../../c-api/module.rst:176
msgid ""
"Setting it to a non-negative value means that the module can be re-"
"initialized and specifies the additional amount of memory it requires for "
"its state. Non-negative ``m_size`` is required for multi-phase "
"initialization."
msgstr ""
"Defini-lo como um valor n&atilde;o negativo significa que o m&oacute;dulo pode ser "
"reinicializado e especifica a quantidade adicional de mem&oacute;ria necess&aacute;ria "
"para seu estado. ``m_size`` n&atilde;o negativo &eacute; necess&aacute;rio para inicializa&ccedil;&atilde;o "
"multif&aacute;sica."

#: ../../c-api/module.rst:181
msgid "See :PEP:`3121` for more details."
msgstr "Ver :PEP:`3121` para mais detalhes."

#: ../../c-api/module.rst:185
msgid ""
"A pointer to a table of module-level functions, described by :c:type:"
"`PyMethodDef` values.  Can be ``NULL`` if no functions are present."
msgstr ""
"Um ponteiro para uma tabela de fun&ccedil;&otilde;es de n&iacute;vel de m&oacute;dulo, descritas por "
"valores :c:type:`PyMethodDef`. Pode ser ``NULL`` se nenhuma fun&ccedil;&atilde;o estiver "
"presente."

#: ../../c-api/module.rst:190
msgid ""
"An array of slot definitions for multi-phase initialization, terminated by a "
"``{0, NULL}`` entry. When using single-phase initialization, *m_slots* must "
"be ``NULL``."
msgstr ""
"Uma matriz de defini&ccedil;&otilde;es de slot para inicializa&ccedil;&atilde;o multif&aacute;sica, terminada "
"por uma entrada ``{0, NULL}``. Ao usar inicializa&ccedil;&atilde;o monof&aacute;sica, *m_slots* "
"deve ser ``NULL``."

#: ../../c-api/module.rst:196
msgid ""
"Prior to version 3.5, this member was always set to ``NULL``, and was "
"defined as:"
msgstr ""
"Antes da vers&atilde;o 3.5, esse membro era sempre definido como ``NULL`` e era "
"definido como:"

#: ../../c-api/module.rst:203
msgid ""
"A traversal function to call during GC traversal of the module object, or "
"``NULL`` if not needed."
msgstr ""
"Uma fun&ccedil;&atilde;o de travessia para chamar durante a travessia do GC do objeto do "
"m&oacute;dulo, ou ``NULL`` se n&atilde;o for necess&aacute;rio."

#: ../../c-api/module.rst:206 ../../c-api/module.rst:221
#: ../../c-api/module.rst:242
msgid ""
"This function is not called if the module state was requested but is not "
"allocated yet. This is the case immediately after the module is created and "
"before the module is executed (:c:data:`Py_mod_exec` function). More "
"precisely, this function is not called if :c:member:`~PyModuleDef.m_size` is "
"greater than 0 and the module state (as returned by :c:func:"
"`PyModule_GetState`) is ``NULL``."
msgstr ""
"Esta fun&ccedil;&atilde;o n&atilde;o &eacute; mais chamada se o estado do m&oacute;dulo foi solicitado, mas "
"ainda n&atilde;o est&aacute; alocado. Este &eacute; o caso imediatamente ap&oacute;s o m&oacute;dulo ser criado "
"e antes de o m&oacute;dulo ser executado (fun&ccedil;&atilde;o :c:data:`Py_mod_exec`). Mais "
"precisamente, esta fun&ccedil;&atilde;o n&atilde;o &eacute; chamada se :c:member:`~PyModuleDef.m_size` "
"for maior que 0 e o estado do m&oacute;dulo (como retornado por :c:func:"
"`PyModule_GetState`) for ``NULL``."

#: ../../c-api/module.rst:213 ../../c-api/module.rst:234
#: ../../c-api/module.rst:249
msgid "No longer called before the module state is allocated."
msgstr "N&atilde;o &eacute; mais chamado antes que o estado do m&oacute;dulo seja alocado."

#: ../../c-api/module.rst:218
msgid ""
"A clear function to call during GC clearing of the module object, or "
"``NULL`` if not needed."
msgstr ""
"Uma fun&ccedil;&atilde;o de limpeza para chamar durante a limpeza do GC do objeto do "
"m&oacute;dulo, ou ``NULL`` se n&atilde;o for necess&aacute;rio."

#: ../../c-api/module.rst:228
msgid ""
"Like :c:member:`PyTypeObject.tp_clear`, this function is not *always* called "
"before a module is deallocated. For example, when reference counting is "
"enough to determine that an object is no longer used, the cyclic garbage "
"collector is not involved and :c:member:`~PyModuleDef.m_free` is called "
"directly."
msgstr ""
"Assim como :c:member:`PyTypeObject.tp_clear`, esta fun&ccedil;&atilde;o n&atilde;o &eacute; *sempre* "
"chamada antes de um m&oacute;dulo ser desalocado. Por exemplo, quando a contagem de "
"refer&ecirc;ncias &eacute; suficiente para determinar que um objeto n&atilde;o &eacute; mais usado, o "
"coletor de lixo c&iacute;clico n&atilde;o &eacute; envolvido e :c:member:`~PyModuleDef.m_free` &eacute; "
"chamado diretamente."

#: ../../c-api/module.rst:239
msgid ""
"A function to call during deallocation of the module object, or ``NULL`` if "
"not needed."
msgstr ""
"Uma fun&ccedil;&atilde;o para ser chamada durante a desaloca&ccedil;&atilde;o do objeto do m&oacute;dulo, ou "
"``NULL`` se n&atilde;o for necess&aacute;rio."

#: ../../c-api/module.rst:253
msgid "Single-phase initialization"
msgstr "inicializa&ccedil;&atilde;o de fase &uacute;nica"

#: ../../c-api/module.rst:255
msgid ""
"The module initialization function may create and return the module object "
"directly. This is referred to as \"single-phase initialization\", and uses "
"one of the following two module creation functions:"
msgstr ""
"A fun&ccedil;&atilde;o de inicializa&ccedil;&atilde;o do m&oacute;dulo pode criar e retornar o objeto do m&oacute;dulo "
"diretamente. Isso &eacute; chamado de \"inicializa&ccedil;&atilde;o de fase &uacute;nica\" e usa uma das "
"duas fun&ccedil;&otilde;es de cria&ccedil;&atilde;o de m&oacute;dulo a seguir:"

#: ../../c-api/module.rst:261
msgid ""
"Create a new module object, given the definition in *def*.  This behaves "
"like :c:func:`PyModule_Create2` with *module_api_version* set to :c:macro:"
"`PYTHON_API_VERSION`."
msgstr ""
"Cria um novo objeto de m&oacute;dulo, dada a defini&ccedil;&atilde;o em *def*. Isso se comporta "
"como :c:func:`PyModule_Create2` com *module_api_version* definido como :c:"
"macro:`PYTHON_API_VERSION`"

#: ../../c-api/module.rst:268
msgid ""
"Create a new module object, given the definition in *def*, assuming the API "
"version *module_api_version*.  If that version does not match the version of "
"the running interpreter, a :exc:`RuntimeWarning` is emitted."
msgstr ""

#: ../../c-api/module.rst:276
msgid ""
"Most uses of this function should be using :c:func:`PyModule_Create` "
"instead; only use this if you are sure you need it."
msgstr ""
"A maioria dos usos dessa fun&ccedil;&atilde;o deve ser feita com :c:func:"
"`PyModule_Create`; use-o apenas se tiver certeza de que precisa."

#: ../../c-api/module.rst:279
msgid ""
"Before it is returned from in the initialization function, the resulting "
"module object is typically populated using functions like :c:func:"
"`PyModule_AddObjectRef`."
msgstr ""

#: ../../c-api/module.rst:285
msgid "Multi-phase initialization"
msgstr "Inicializa&ccedil;&atilde;o multif&aacute;sica"

#: ../../c-api/module.rst:287
msgid ""
"An alternate way to specify extensions is to request \"multi-phase "
"initialization\". Extension modules created this way behave more like Python "
"modules: the initialization is split between the *creation phase*, when the "
"module object is created, and the *execution phase*, when it is populated. "
"The distinction is similar to the :py:meth:`!__new__` and :py:meth:`!"
"__init__` methods of classes."
msgstr ""

#: ../../c-api/module.rst:294
msgid ""
"Unlike modules created using single-phase initialization, these modules are "
"not singletons: if the *sys.modules* entry is removed and the module is re-"
"imported, a new module object is created, and the old module is subject to "
"normal garbage collection -- as with Python modules. By default, multiple "
"modules created from the same definition should be independent: changes to "
"one should not affect the others. This means that all state should be "
"specific to the module object (using e.g. using :c:func:"
"`PyModule_GetState`), or its contents (such as the module's :attr:`~object."
"__dict__` or individual classes created with :c:func:`PyType_FromSpec`)."
msgstr ""

#: ../../c-api/module.rst:304
msgid ""
"All modules created using multi-phase initialization are expected to "
"support :ref:`sub-interpreters <sub-interpreter-support>`. Making sure "
"multiple modules are independent is typically enough to achieve this."
msgstr ""

#: ../../c-api/module.rst:308
msgid ""
"To request multi-phase initialization, the initialization function "
"(PyInit_modulename) returns a :c:type:`PyModuleDef` instance with non-empty :"
"c:member:`~PyModuleDef.m_slots`. Before it is returned, the ``PyModuleDef`` "
"instance must be initialized with the following function:"
msgstr ""

#: ../../c-api/module.rst:315
msgid ""
"Ensures a module definition is a properly initialized Python object that "
"correctly reports its type and reference count."
msgstr ""
"Garante que uma defini&ccedil;&atilde;o de m&oacute;dulo &eacute; um objeto Python devidamente "
"inicializado que reporta corretamente seu tipo e contagem de refer&ecirc;ncias."

#: ../../c-api/module.rst:318
msgid "Returns *def* cast to ``PyObject*``, or ``NULL`` if an error occurred."
msgstr ""

#: ../../c-api/module.rst:322
msgid ""
"The *m_slots* member of the module definition must point to an array of "
"``PyModuleDef_Slot`` structures:"
msgstr ""

#: ../../c-api/module.rst:329
msgid "A slot ID, chosen from the available values explained below."
msgstr ""
"Um ID de lot, escolhido a partir dos valores dispon&iacute;veis explicados abaixo."

#: ../../c-api/module.rst:333
msgid "Value of the slot, whose meaning depends on the slot ID."
msgstr "Valor do slot, cujo significado depende do ID do slot."

#: ../../c-api/module.rst:337
msgid "The *m_slots* array must be terminated by a slot with id 0."
msgstr ""

#: ../../c-api/module.rst:339
msgid "The available slot types are:"
msgstr "Os tipos de slot dispon&iacute;veis s&atilde;o:"

#: ../../c-api/module.rst:343
msgid ""
"Specifies a function that is called to create the module object itself. The "
"*value* pointer of this slot must point to a function of the signature:"
msgstr ""

#: ../../c-api/module.rst:350
msgid ""
"The function receives a :py:class:`~importlib.machinery.ModuleSpec` "
"instance, as defined in :PEP:`451`, and the module definition. It should "
"return a new module object, or set an error and return ``NULL``."
msgstr ""

#: ../../c-api/module.rst:355
msgid ""
"This function should be kept minimal. In particular, it should not call "
"arbitrary Python code, as trying to import the same module again may result "
"in an infinite loop."
msgstr ""

#: ../../c-api/module.rst:359
msgid ""
"Multiple ``Py_mod_create`` slots may not be specified in one module "
"definition."
msgstr ""
"M&uacute;ltiplos slots ``Py_mod_create`` podem n&atilde;o estar especificados em uma "
"defini&ccedil;&atilde;o de m&oacute;dulo."

#: ../../c-api/module.rst:362
msgid ""
"If ``Py_mod_create`` is not specified, the import machinery will create a "
"normal module object using :c:func:`PyModule_New`. The name is taken from "
"*spec*, not the definition, to allow extension modules to dynamically adjust "
"to their place in the module hierarchy and be imported under different names "
"through symlinks, all while sharing a single module definition."
msgstr ""

#: ../../c-api/module.rst:368
msgid ""
"There is no requirement for the returned object to be an instance of :c:type:"
"`PyModule_Type`. Any type can be used, as long as it supports setting and "
"getting import-related attributes. However, only ``PyModule_Type`` instances "
"may be returned if the ``PyModuleDef`` has non-``NULL`` ``m_traverse``, "
"``m_clear``, ``m_free``; non-zero ``m_size``; or slots other than "
"``Py_mod_create``."
msgstr ""

#: ../../c-api/module.rst:377
msgid ""
"Specifies a function that is called to *execute* the module. This is "
"equivalent to executing the code of a Python module: typically, this "
"function adds classes and constants to the module. The signature of the "
"function is:"
msgstr ""

#: ../../c-api/module.rst:386
msgid ""
"If multiple ``Py_mod_exec`` slots are specified, they are processed in the "
"order they appear in the *m_slots* array."
msgstr ""
"Se v&aacute;rios slots ``Py_mod_exec`` forem especificados, eles ser&atilde;o processados "
"na ordem em que aparecem no vetor *m_slots*."

#: ../../c-api/module.rst:391 ../../c-api/module.rst:424
msgid "Specifies one of the following values:"
msgstr ""

#: ../../c-api/module.rst:397
msgid "The module does not support being imported in subinterpreters."
msgstr ""

#: ../../c-api/module.rst:401
msgid ""
"The module supports being imported in subinterpreters, but only when they "
"share the main interpreter's GIL. (See :ref:`isolating-extensions-howto`.)"
msgstr ""

#: ../../c-api/module.rst:407
msgid ""
"The module supports being imported in subinterpreters, even when they have "
"their own GIL. (See :ref:`isolating-extensions-howto`.)"
msgstr ""

#: ../../c-api/module.rst:411
msgid ""
"This slot determines whether or not importing this module in a "
"subinterpreter will fail."
msgstr ""

#: ../../c-api/module.rst:414
msgid ""
"Multiple ``Py_mod_multiple_interpreters`` slots may not be specified in one "
"module definition."
msgstr ""

#: ../../c-api/module.rst:417
msgid ""
"If ``Py_mod_multiple_interpreters`` is not specified, the import machinery "
"defaults to ``Py_MOD_MULTIPLE_INTERPRETERS_SUPPORTED``."
msgstr ""

#: ../../c-api/module.rst:430
msgid ""
"The module depends on the presence of the global interpreter lock (GIL), and "
"may access global state without synchronization."
msgstr ""

#: ../../c-api/module.rst:435
msgid "The module is safe to run without an active GIL."
msgstr ""

#: ../../c-api/module.rst:437
msgid ""
"This slot is ignored by Python builds not configured with :option:`--disable-"
"gil`.  Otherwise, it determines whether or not importing this module will "
"cause the GIL to be automatically enabled. See :ref:`whatsnew313-free-"
"threaded-cpython` for more detail."
msgstr ""

#: ../../c-api/module.rst:442
msgid ""
"Multiple ``Py_mod_gil`` slots may not be specified in one module definition."
msgstr ""

#: ../../c-api/module.rst:444
msgid ""
"If ``Py_mod_gil`` is not specified, the import machinery defaults to "
"``Py_MOD_GIL_USED``."
msgstr ""

#: ../../c-api/module.rst:449
msgid "See :PEP:`489` for more details on multi-phase initialization."
msgstr ""
"Ver :PEP:`489` para obter mais detalhes sobre a inicializa&ccedil;&atilde;o multif&aacute;sica."

#: ../../c-api/module.rst:452
msgid "Low-level module creation functions"
msgstr "Fun&ccedil;&otilde;es de cria&ccedil;&atilde;o de m&oacute;dulo de baixo n&iacute;vel"

#: ../../c-api/module.rst:454
msgid ""
"The following functions are called under the hood when using multi-phase "
"initialization. They can be used directly, for example when creating module "
"objects dynamically. Note that both ``PyModule_FromDefAndSpec`` and "
"``PyModule_ExecDef`` must be called to fully initialize a module."
msgstr ""

#: ../../c-api/module.rst:461
msgid ""
"Create a new module object, given the definition in *def* and the ModuleSpec "
"*spec*.  This behaves like :c:func:`PyModule_FromDefAndSpec2` with "
"*module_api_version* set to :c:macro:`PYTHON_API_VERSION`."
msgstr ""

#: ../../c-api/module.rst:469
msgid ""
"Create a new module object, given the definition in *def* and the ModuleSpec "
"*spec*, assuming the API version *module_api_version*. If that version does "
"not match the version of the running interpreter, a :exc:`RuntimeWarning` is "
"emitted."
msgstr ""

#: ../../c-api/module.rst:478
msgid ""
"Most uses of this function should be using :c:func:`PyModule_FromDefAndSpec` "
"instead; only use this if you are sure you need it."
msgstr ""

#: ../../c-api/module.rst:485
msgid "Process any execution slots (:c:data:`Py_mod_exec`) given in *def*."
msgstr ""

#: ../../c-api/module.rst:491
msgid ""
"Set the docstring for *module* to *docstring*. This function is called "
"automatically when creating a module from ``PyModuleDef``, using either "
"``PyModule_Create`` or ``PyModule_FromDefAndSpec``."
msgstr ""

#: ../../c-api/module.rst:500
msgid ""
"Add the functions from the ``NULL`` terminated *functions* array to "
"*module*. Refer to the :c:type:`PyMethodDef` documentation for details on "
"individual entries (due to the lack of a shared module namespace, module "
"level \"functions\" implemented in C typically receive the module as their "
"first parameter, making them similar to instance methods on Python classes). "
"This function is called automatically when creating a module from "
"``PyModuleDef``, using either ``PyModule_Create`` or "
"``PyModule_FromDefAndSpec``."
msgstr ""

#: ../../c-api/module.rst:512
msgid "Support functions"
msgstr ""

#: ../../c-api/module.rst:514
msgid ""
"The module initialization function (if using single phase initialization) or "
"a function called from a module execution slot (if using multi-phase "
"initialization), can use the following functions to help initialize the "
"module state:"
msgstr ""

#: ../../c-api/module.rst:521
msgid ""
"Add an object to *module* as *name*.  This is a convenience function which "
"can be used from the module's initialization function."
msgstr ""

#: ../../c-api/module.rst:524
msgid ""
"On success, return ``0``. On error, raise an exception and return ``-1``."
msgstr ""

#: ../../c-api/module.rst:526 ../../c-api/module.rst:577
#: ../../c-api/module.rst:604
msgid "Example usage::"
msgstr "Exemplo de uso::"

#: ../../c-api/module.rst:528
msgid ""
"static int\n"
"add_spam(PyObject *module, int value)\n"
"{\n"
"    PyObject *obj = PyLong_FromLong(value);\n"
"    if (obj == NULL) {\n"
"        return -1;\n"
"    }\n"
"    int res = PyModule_AddObjectRef(module, \"spam\", obj);\n"
"    Py_DECREF(obj);\n"
"    return res;\n"
" }"
msgstr ""

#: ../../c-api/module.rst:540
msgid ""
"To be convenient, the function accepts ``NULL`` *value* with an exception "
"set. In this case, return ``-1`` and just leave the raised exception "
"unchanged."
msgstr ""

#: ../../c-api/module.rst:544
msgid ""
"The example can also be written without checking explicitly if *obj* is "
"``NULL``::"
msgstr ""
"O exemplo tamb&eacute;m pode ser escrito sem verificar explicitamente se *obj* &eacute; "
"``NULL``::"

#: ../../c-api/module.rst:547
msgid ""
"static int\n"
"add_spam(PyObject *module, int value)\n"
"{\n"
"    PyObject *obj = PyLong_FromLong(value);\n"
"    int res = PyModule_AddObjectRef(module, \"spam\", obj);\n"
"    Py_XDECREF(obj);\n"
"    return res;\n"
" }"
msgstr ""

#: ../../c-api/module.rst:556
msgid ""
"Note that ``Py_XDECREF()`` should be used instead of ``Py_DECREF()`` in this "
"case, since *obj* can be ``NULL``."
msgstr ""

#: ../../c-api/module.rst:559
msgid ""
"The number of different *name* strings passed to this function should be "
"kept small, usually by only using statically allocated strings as *name*. "
"For names that aren't known at compile time, prefer calling :c:func:"
"`PyUnicode_FromString` and :c:func:`PyObject_SetAttr` directly. For more "
"details, see :c:func:`PyUnicode_InternFromString`, which may be used "
"internally to create a key object."
msgstr ""

#: ../../c-api/module.rst:572
msgid ""
"Similar to :c:func:`PyModule_AddObjectRef`, but \"steals\" a reference to "
"*value*. It can be called with a result of function that returns a new "
"reference without bothering to check its result or even saving it to a "
"variable."
msgstr ""

#: ../../c-api/module.rst:579
msgid ""
"if (PyModule_Add(module, \"spam\", PyBytes_FromString(value)) < 0) {\n"
"    goto error;\n"
"}"
msgstr ""

#: ../../c-api/module.rst:588
msgid ""
"Similar to :c:func:`PyModule_AddObjectRef`, but steals a reference to "
"*value* on success (if it returns ``0``)."
msgstr ""

#: ../../c-api/module.rst:591
msgid ""
"The new :c:func:`PyModule_Add` or :c:func:`PyModule_AddObjectRef` functions "
"are recommended, since it is easy to introduce reference leaks by misusing "
"the :c:func:`PyModule_AddObject` function."
msgstr ""

#: ../../c-api/module.rst:598
msgid ""
"Unlike other functions that steal references, ``PyModule_AddObject()`` only "
"releases the reference to *value* **on success**."
msgstr ""

#: ../../c-api/module.rst:601
msgid ""
"This means that its return value must be checked, and calling code must :c:"
"func:`Py_XDECREF` *value* manually on error."
msgstr ""

#: ../../c-api/module.rst:606
msgid ""
"PyObject *obj = PyBytes_FromString(value);\n"
"if (PyModule_AddObject(module, \"spam\", obj) < 0) {\n"
"    // If 'obj' is not NULL and PyModule_AddObject() failed,\n"
"    // 'obj' strong reference must be deleted with Py_XDECREF().\n"
"    // If 'obj' is NULL, Py_XDECREF() does nothing.\n"
"    Py_XDECREF(obj);\n"
"    goto error;\n"
"}\n"
"// PyModule_AddObject() stole a reference to obj:\n"
"// Py_XDECREF(obj) is not needed here."
msgstr ""

#: ../../c-api/module.rst:619
msgid ":c:func:`PyModule_AddObject` is :term:`soft deprecated`."
msgstr ""

#: ../../c-api/module.rst:624
msgid ""
"Add an integer constant to *module* as *name*.  This convenience function "
"can be used from the module's initialization function. Return ``-1`` with an "
"exception set on error, ``0`` on success."
msgstr ""

#: ../../c-api/module.rst:628
msgid ""
"This is a convenience function that calls :c:func:`PyLong_FromLong` and :c:"
"func:`PyModule_AddObjectRef`; see their documentation for details."
msgstr ""

#: ../../c-api/module.rst:634
msgid ""
"Add a string constant to *module* as *name*.  This convenience function can "
"be used from the module's initialization function.  The string *value* must "
"be ``NULL``-terminated. Return ``-1`` with an exception set on error, ``0`` "
"on success."
msgstr ""

#: ../../c-api/module.rst:639
msgid ""
"This is a convenience function that calls :c:func:"
"`PyUnicode_InternFromString` and :c:func:`PyModule_AddObjectRef`; see their "
"documentation for details."
msgstr ""

#: ../../c-api/module.rst:646
msgid ""
"Add an int constant to *module*. The name and the value are taken from "
"*macro*. For example ``PyModule_AddIntMacro(module, AF_INET)`` adds the int "
"constant *AF_INET* with the value of *AF_INET* to *module*. Return ``-1`` "
"with an exception set on error, ``0`` on success."
msgstr ""

#: ../../c-api/module.rst:654
msgid "Add a string constant to *module*."
msgstr ""

#: ../../c-api/module.rst:658
msgid ""
"Add a type object to *module*. The type object is finalized by calling "
"internally :c:func:`PyType_Ready`. The name of the type object is taken from "
"the last component of :c:member:`~PyTypeObject.tp_name` after dot. Return "
"``-1`` with an exception set on error, ``0`` on success."
msgstr ""

#: ../../c-api/module.rst:668
msgid ""
"Indicate that *module* does or does not support running without the global "
"interpreter lock (GIL), using one of the values from :c:macro:`Py_mod_gil`. "
"It must be called during *module*'s initialization function. If this "
"function is not called during module initialization, the import machinery "
"assumes the module does not support running without the GIL. This function "
"is only available in Python builds configured with :option:`--disable-gil`. "
"Return ``-1`` with an exception set on error, ``0`` on success."
msgstr ""

#: ../../c-api/module.rst:681
msgid "Module lookup"
msgstr "Pesquisa por m&oacute;dulos"

#: ../../c-api/module.rst:683
msgid ""
"Single-phase initialization creates singleton modules that can be looked up "
"in the context of the current interpreter. This allows the module object to "
"be retrieved later with only a reference to the module definition."
msgstr ""

#: ../../c-api/module.rst:687
msgid ""
"These functions will not work on modules created using multi-phase "
"initialization, since multiple such modules can be created from a single "
"definition."
msgstr ""

#: ../../c-api/module.rst:692
msgid ""
"Returns the module object that was created from *def* for the current "
"interpreter. This method requires that the module object has been attached "
"to the interpreter state with :c:func:`PyState_AddModule` beforehand. In "
"case the corresponding module object is not found or has not been attached "
"to the interpreter state yet, it returns ``NULL``."
msgstr ""

#: ../../c-api/module.rst:699
msgid ""
"Attaches the module object passed to the function to the interpreter state. "
"This allows the module object to be accessible via :c:func:"
"`PyState_FindModule`."
msgstr ""

#: ../../c-api/module.rst:702
msgid "Only effective on modules created using single-phase initialization."
msgstr ""

#: ../../c-api/module.rst:704
msgid ""
"Python calls ``PyState_AddModule`` automatically after importing a module, "
"so it is unnecessary (but harmless) to call it from module initialization "
"code. An explicit call is needed only if the module's own init code "
"subsequently calls ``PyState_FindModule``. The function is mainly intended "
"for implementing alternative import mechanisms (either by calling it "
"directly, or by referring to its implementation for details of the required "
"state updates)."
msgstr ""

#: ../../c-api/module.rst:712 ../../c-api/module.rst:723
msgid "The caller must hold the GIL."
msgstr ""

#: ../../c-api/module.rst:714
msgid "Return ``-1`` with an exception set on error, ``0`` on success."
msgstr ""
"Retorna ``-1`` com uma exce&ccedil;&atilde;o definida em caso de erro, ``0`` em caso de "
"sucesso."

#: ../../c-api/module.rst:720
msgid ""
"Removes the module object created from *def* from the interpreter state. "
"Return ``-1`` with an exception set on error, ``0`` on success."
msgstr ""

#: ../../c-api/module.rst:8
msgid "object"
msgstr "objeto"

#: ../../c-api/module.rst:8
msgid "module"
msgstr "m&oacute;dulo"

#: ../../c-api/module.rst:13
msgid "ModuleType (in module types)"
msgstr ""

#: ../../c-api/module.rst:33 ../../c-api/module.rst:77
msgid "__name__ (module attribute)"
msgstr "__name__ (atributo de m&oacute;dulo)"

#: ../../c-api/module.rst:33
msgid "__doc__ (module attribute)"
msgstr "__doc__ (atributo de m&oacute;dulo)"

#: ../../c-api/module.rst:33 ../../c-api/module.rst:108
msgid "__file__ (module attribute)"
msgstr "__file__ (atributo de m&oacute;dulo)"

#: ../../c-api/module.rst:33
msgid "__package__ (module attribute)"
msgstr "__package__ (atributo de m&oacute;dulo)"

#: ../../c-api/module.rst:33
msgid "__loader__ (module attribute)"
msgstr "__loader__ (atributo de m&oacute;dulo)"

#: ../../c-api/module.rst:63
msgid "__dict__ (module attribute)"
msgstr "__dict__ (atributo de m&oacute;dulo)"

#: ../../c-api/module.rst:77 ../../c-api/module.rst:108
msgid "SystemError (built-in exception)"
msgstr ""