module.po

# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2001-2020, Python Software Foundation
# This file is distributed under the same license as the Python package.
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
#
# Translators:
# tomo, 2019
#
#, fuzzy
msgid ""
msgstr ""
"Project-Id-Version: Python 3.6\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2020-02-09 18:48+0900\n"
"PO-Revision-Date: 2018-06-29 17:48+0000\n"
"Last-Translator: tomo, 2019\n"
"Language-Team: Japanese (https://www.transifex.com/python-doc/teams/5390/"
"ja/)\n"
"Language: ja\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Plural-Forms: nplurals=1; plural=0;\n"

#: ../../c-api/module.rst:6
msgid "Module Objects"
msgstr "モジュールオブジェクト (module object)"

#: ../../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 ""
"この :c:type:`PyTypeObject` のインスタンスは Python のモジュールオブジェクト"
"型を表現します。このオブジェクトは、Python プログラムには ``types."
"ModuleType``  として公開されています。"

#: ../../c-api/module.rst:21
msgid "Return true if *p* is a module object, or a subtype of a module object."
msgstr ""
"*p* がモジュールオブジェクトかモジュールオブジェクトのサブタイプであるときに"
"真を返します。"

#: ../../c-api/module.rst:26
msgid ""
"Return true if *p* is a module object, but not a subtype of :c:data:"
"`PyModule_Type`."
msgstr ""
"*p* がモジュールオブジェクトで、かつモジュールオブジェクトのサブタイプでない"
"ときに真を返します。 :c:data:`PyModule_Type`."

#: ../../c-api/module.rst:39
msgid ""
"Return a new module object with the :attr:`__name__` attribute set to "
"*name*. The module's :attr:`__name__`, :attr:`__doc__`, :attr:`__package__`, "
"and :attr:`__loader__` attributes are filled in (all but :attr:`__name__` "
"are set to ``None``); the caller is responsible for providing a :attr:"
"`__file__` attribute."
msgstr ""
":attr:`__name__` 属性に *name* が設定された新しいモジュールオブジェクトを返し"
"ます。\n"
"モジュールの :attr:`__name__`, :attr:`__doc__`, :attr:`__package__`, :attr:"
"`__loader__` 属性に値が入っています (:attr:`__name__` 以外は全て ``None`` で"
"す);\n"
":attr:`__file__` 属性に値を入れるのは呼び出し側の責任です。"

#: ../../c-api/module.rst:47
msgid ":attr:`__package__` and :attr:`__loader__` are set to ``None``."
msgstr ":attr:`__package__` と :attr:`__loader__` は ``None`` に設定されます。"

#: ../../c-api/module.rst:53
msgid ""
"Similar to :c:func:`PyModule_NewObject`, but the name is a UTF-8 encoded "
"string instead of a Unicode object."
msgstr ""
":c:func:`PyModule_NewObject` に似ていますが、 name は Unicode オブジェクトで"
"はなく UTF-8 でエンコードされた文字列です。"

#: ../../c-api/module.rst:61
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 ""
"*module* の名前空間を実装する辞書オブジェクトを返します;\n"
"このオブジェクトは、モジュールオブジェクトの :attr:`~object.__dict__` 属性と"
"同じものです。\n"
"*module* がモジュールオブジェクト (もしくはモジュールオブジェクトのサブタイ"
"プ) でない場合は、 :exc:`SystemError` が送出され *NULL* が返されます。"

#: ../../c-api/module.rst:66
msgid ""
"It is recommended extensions use other :c:func:`PyModule_\\*` and :c:func:"
"`PyObject_\\*` functions rather than directly manipulate a module's :attr:"
"`~object.__dict__`."
msgstr ""
"拡張モジュールでは、モジュールの :attr:`~object.__dict__` を直接操作するより"
"も、 :c:func:`PyModule_\\*` および :c:func:`PyObject_\\*` 関数を使う方が推奨"
"されます。"

#: ../../c-api/module.rst:77
msgid ""
"Return *module*'s :attr:`__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 ""
"*module* の :attr:`__name__` の値を返します。モジュールがこの属性を提供してい"
"ない場合や文字列型でない場合、 :exc:`SystemError` を送出して *NULL* を返しま"
"す。"

#: ../../c-api/module.rst:85
msgid ""
"Similar to :c:func:`PyModule_GetNameObject` but return the name encoded to "
"``'utf-8'``."
msgstr ""
":c:func:`PyModule_GetNameObject` に似ていますが、 ``'utf-8'`` でエンコードさ"
"れた name を返します。"

#: ../../c-api/module.rst:90
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 ""
"モジュールの \"state\"(モジュールを生成したタイミングで確保されるメモリブロッ"
"クへのポインター) か、なければ *NULL* を返します。 :c:member:`PyModuleDef."
"m_size` を参照してください。"

#: ../../c-api/module.rst:97
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 ""
"モジュールが作られる元となった :c:type:`PyModuleDef` 構造体へのポインタを返し"
"ます。\n"
"モジュールが定義によって作られていなかった場合は *NULL* を返します。"

#: ../../c-api/module.rst:107
msgid ""
"Return the name of the file from which *module* was loaded using *module*'s :"
"attr:`__file__` attribute.  If this is not defined, or if it is not a "
"unicode string, raise :exc:`SystemError` and return *NULL*; otherwise return "
"a reference to a Unicode object."
msgstr ""
"*module* の :attr:`__file__` 属性をもとに *module* がロードされたもとのファイ"
"ル名を返します。もしファイル名が定義されていない場合や、 Unicode 文字列ではな"
"い場合、 :exc:`SystemError` を発生させて *NULL* を返します。それ以外の場合は "
"Unicode オブジェクトへの参照を返します。"

#: ../../c-api/module.rst:117
msgid ""
"Similar to :c:func:`PyModule_GetFilenameObject` but return the filename "
"encoded to 'utf-8'."
msgstr ""
":c:func:`PyModule_GetFilenameObject` と似ていますが、 'utf-8' でエンコードさ"
"れたファイル名を返します。"

#: ../../c-api/module.rst:120
msgid ""
":c:func:`PyModule_GetFilename` raises :c:type:`UnicodeEncodeError` on "
"unencodable filenames, use :c:func:`PyModule_GetFilenameObject` instead."
msgstr ""
":c:func:`PyModule_GetFilename` はエンコードできないファイル名に対しては :c:"
"type:`UnicodeEncodeError` を送出します。これの代わりに :c:func:"
"`PyModule_GetFilenameObject` を使用してください。"

#: ../../c-api/module.rst:128
msgid "Initializing C modules"
msgstr "Cモジュールの初期化"

#: ../../c-api/module.rst:130
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 ""
"通常、モジュールオブジェクトは拡張モジュール (初期化関数をエクスポートしてい"
"る共有ライブラリ) または組み込まれたモジュール (:c:func:"
"`PyImport_AppendInittab` を使って初期化関数が追加されているモジュール) から作"
"られます。\n"
"詳細については :ref:`building` または :ref:`extending-with-embedding` を見て"
"ください。"

#: ../../c-api/module.rst:135
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 ""
"初期化関数は、モジュール定義のインスタンスを :c:func:`PyModule_Create` に渡し"
"て出来上がったモジュールオブジェクトを返してもよいですし、もしくは定義構造体"
"そのものを返し\"多段階初期化\"を要求しても構いません。"

#: ../../c-api/module.rst:141
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 ""
"モジュール定義構造体はモジュールオブジェクトを生成するのに必要なすべての情報"
"を保持します。\n"
"通常は、それぞれのモジュールごとに静的に初期化されたこの型の変数が1つだけ存在"
"します。"

#: ../../c-api/module.rst:147
msgid "Always initialize this member to :const:`PyModuleDef_HEAD_INIT`."
msgstr ""
"このメンバーは常に :const:`PyModuleDef_HEAD_INIT` で初期化してください。"

#: ../../c-api/module.rst:151
msgid "Name for the new module."
msgstr "新しいモジュールの名前。"

#: ../../c-api/module.rst:155
msgid ""
"Docstring for the module; usually a docstring variable created with :c:func:"
"`PyDoc_STRVAR` is used."
msgstr ""
"モジュールの docstring。たいてい docstring は :c:func:`PyDoc_STRVAR` を利用し"
"て生成されます。"

#: ../../c-api/module.rst:160
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 ""
"モジュールの状態は、静的なグローバルな領域ではなく :c:func:"
"`PyModule_GetState` で取得できるモジュールごとのメモリ領域に保持されているこ"
"とがあります。\n"
"これによってモジュールは複数のサブ・インタプリターで安全に使えます。"

#: ../../c-api/module.rst:164
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:`m_free` "
"function has been called, if present."
msgstr ""
"このメモリ領域は *m_size* に基づいてモジュール作成時に確保され、モジュールオ"
"ブジェクトが破棄されるときに、 :c:member:`m_free` 関数があればそれが呼ばれた"
"後で解放されます。"

#: ../../c-api/module.rst:168
msgid ""
"Setting ``m_size`` to ``-1`` means that the module does not support sub-"
"interpreters, because it has global state."
msgstr ""
"``m_size`` に ``-1`` を設定すると、そのモジュールはグローバルな状態を持つため"
"にサブ・インタープリターをサポートしていないということになります。"

#: ../../c-api/module.rst:171
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 ""
"``m_size`` を非負の値に設定すると、モジュールは再初期化でき、その状態のために"
"必要となる追加のメモリ量を指定できるということになります。\n"
"非負の ``m_size`` は多段階初期化で必要になります。"

#: ../../c-api/module.rst:176
msgid "See :PEP:`3121` for more details."
msgstr "詳細は :PEP:`3121` を参照。"

#: ../../c-api/module.rst:180
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 ""
":c:type:`PyMethodDef` で定義される、モジュールレベル関数のテーブルへのポイン"
"ター。関数が存在しない場合は *NULL* を設定することが可能。"

#: ../../c-api/module.rst:185
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 ""
"多段階初期化のためのスロット定義の配列で、 ``{0, NULL}`` 要素が終端となりま"
"す。\n"
"一段階初期化を使うときは、 *m_slots* は *NULL* でなければなりません。"

#: ../../c-api/module.rst:191
msgid ""
"Prior to version 3.5, this member was always set to *NULL*, and was defined "
"as:"
msgstr ""
"バージョン 3.5 より前は、このメンバは常に *NULL* に設定されていて、次のものと"
"して定義されていました:"

#: ../../c-api/module.rst:198
msgid ""
"A traversal function to call during GC traversal of the module object, or "
"*NULL* if not needed. This function may be called before module state is "
"allocated (:c:func:`PyModule_GetState()` may return `NULL`), and before the :"
"c:member:`Py_mod_exec` function is executed."
msgstr ""

#: ../../c-api/module.rst:205
msgid ""
"A clear function to call during GC clearing of the module object, or *NULL* "
"if not needed. This function may be called before module state is allocated "
"(:c:func:`PyModule_GetState()` may return `NULL`), and before the :c:member:"
"`Py_mod_exec` function is executed."
msgstr ""

#: ../../c-api/module.rst:212
msgid ""
"A function to call during deallocation of the module object, or *NULL* if "
"not needed. This function may be called before module state is allocated (:c:"
"func:`PyModule_GetState()` may return `NULL`), and before the :c:member:"
"`Py_mod_exec` function is executed."
msgstr ""

#: ../../c-api/module.rst:218
msgid "Single-phase initialization"
msgstr "一段階初期化"

#: ../../c-api/module.rst:220
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 ""
"モジュールの初期化関数が直接モジュールオブジェクトを生成して返す場合がありま"
"す。\n"
"これは\"一段階初期化\"と呼ばれ、次の2つのモジュール生成関数のどちらか1つを使"
"います:"

#: ../../c-api/module.rst:226
msgid ""
"Create a new module object, given the definition in *def*.  This behaves "
"like :c:func:`PyModule_Create2` with *module_api_version* set to :const:"
"`PYTHON_API_VERSION`."
msgstr ""
"*def* での定義に従って新しいモジュールオブジェクトを生成します。\n"
"これは :c:func:`PyModule_Create2` の *module_api_version* に :const:"
"`PYTHON_API_VERSION` を設定したときのように振る舞います。"

#: ../../c-api/module.rst:233
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 ""
"APIバージョンを *module_api_version* として *def* での定義に従って新しいモ"
"ジュールオブジェクトを生成します。\n"
"もし指定されたバージョンが実行しているインタープリターのバージョンと異なる場"
"合は、 :exc:`RuntimeWarning` を発生させます。"

#: ../../c-api/module.rst:239
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 ""
"ほとんどの場合、この関数ではなく :c:func:`PyModule_Create` を利用するべきで"
"す。この関数は、この関数の必要性を理解しているときにだけ利用してください。"

#: ../../c-api/module.rst:242
msgid ""
"Before it is returned from in the initialization function, the resulting "
"module object is typically populated using functions like :c:func:"
"`PyModule_AddObject`."
msgstr ""
"モジュールオブジェクトが初期化関数から返される前に、たいていは :c:func:"
"`PyModule_AddObject` などの関数を使ってモジュールオブジェクトにメンバを所属さ"
"せます。"

#: ../../c-api/module.rst:248
msgid "Multi-phase initialization"
msgstr "多段階初期化"

#: ../../c-api/module.rst:250
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 ""
"拡張を直接生成するもう1つのやり方は、\"多段階初期化\"を要求する方法です。\n"
"この方法で作られる拡張モジュールは、よりPythonモジュールに近い振る舞いをしま"
"す:\n"
"初期化処理は、モジュールオブジェクトを生成する *生成段階* とメンバを所属させ"
"る *実行段階* に分割されます。\n"
"この区別はクラスの :py:meth:`__new__` メソッドと :py:meth:`__init__` メソッド"
"に似ています。"

#: ../../c-api/module.rst:257
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:`__dict__` "
"or individual classes created with :c:func:`PyType_FromSpec`)."
msgstr ""
"一段階初期化で生成されたモジュールと違い、多段階初期化で生成されたモジュール"
"はシングルトンではありません:\n"
"*sys.modules* のエントリーが削除されモジュールが再インポートされた場合、新し"
"いモジュールオブジェクトが生成され、古いモジュールはPythonモジュールと同じよ"
"うに通常のガベージコレクションで処理されることになります。\n"
"デフォルトでは、同じ定義から作られた複数のモジュールは独立であるべきです: あ"
"るインスタンスに加えた変更は別のインスタンスに影響しません。\n"
"これは、(例えば :c:func:`PyModule_GetState` を使って取得できる) 全ての状態"
"や、(モジュールの :attr:`__dict__` や :c:func:`PyType_FromSpec` で生成された"
"個々のクラスのような) モジュールに所属するものは、特定のモジュールオブジェク"
"ト特有のものであるべきということです。"

#: ../../c-api/module.rst:267
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 ""
"多段階初期化を使って生成される全てのモジュールは :ref:`サブ・インタプリター "
"<sub-interpreter-support>` をサポートすることが求められます。\n"
"複数のモジュールが独立していることを保証するのには、たいていはこのサポートを"
"するだけで十分です。"

#: ../../c-api/module.rst:271
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 ""
"多段階初期化を要求するために、初期化関数 (PyInit_modulename) は空でない :c:"
"member:`~PyModuleDef.m_slots` を持つ :c:type:`PyModuleDef` を返します。\n"
"これを返す前に、 ``PyModuleDef`` インスタンスは次の関数で初期化されなくてはい"
"けません:"

#: ../../c-api/module.rst:278
msgid ""
"Ensures a module definition is a properly initialized Python object that "
"correctly reports its type and reference count."
msgstr ""
"モジュール定義が型と参照カウントを正しく報告する、適切に初期化された Python "
"オブジェクトであること保証します。"

#: ../../c-api/module.rst:281
msgid "Returns *def* cast to ``PyObject*``, or *NULL* if an error occurred."
msgstr ""
"``PyObject*`` にキャストされた *def* を返します。エラーが発生した場合 *NULL* "
"を返します。"

#: ../../c-api/module.rst:285
msgid ""
"The *m_slots* member of the module definition must point to an array of "
"``PyModuleDef_Slot`` structures:"
msgstr ""
"モジュール定義の *m_slots* メンバは ``PyModuleDef_Slot`` 構造体の配列を指さな"
"ければなりません:"

#: ../../c-api/module.rst:292
msgid "A slot ID, chosen from the available values explained below."
msgstr "スロット ID で、以下で説明されている利用可能な値から選ばれます。"

#: ../../c-api/module.rst:296
msgid "Value of the slot, whose meaning depends on the slot ID."
msgstr "スロットの値で、意味はスロット ID に依存します。"

#: ../../c-api/module.rst:300
msgid "The *m_slots* array must be terminated by a slot with id 0."
msgstr "*m_slots* 配列はID 0 のスロットで終端されていなければなりません。"

#: ../../c-api/module.rst:302
msgid "The available slot types are:"
msgstr "利用可能なスロットの型は以下です:"

#: ../../c-api/module.rst:306
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 ""
"モジュールオブジェクト自身を生成するために呼ばれる関数を指定します。\n"
"このスロットの *value* ポインタは次のシグネチャを持つ関数を指していなくてはい"
"けません:"

#: ../../c-api/module.rst:311
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 ""
":PEP:`451` で定義された :py:class:`~importlib.machinery.ModuleSpec` インスタ"
"ンスと、モジュール定義を受け取る関数です。\n"
"これは新しいモジュールオブジェクトを返すか、エラーを設定して *NULL* を返すべ"
"きです。"

#: ../../c-api/module.rst:316
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 ""
"この関数は最小限に留めておくべきです。\n"
"特に任意のPythonコードを呼び出すべきではなく、同じモジュールをインポートしよ"
"うとすると無限ループに陥るでしょう。"

#: ../../c-api/module.rst:320
msgid ""
"Multiple ``Py_mod_create`` slots may not be specified in one module "
"definition."
msgstr ""
"複数の ``Py_mod_create`` スロットを1つのモジュール定義に設定しない方がよいで"
"す。"

#: ../../c-api/module.rst:323
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 ""
"``Py_mod_create`` が設定されていない場合は、インポート機構は :c:func:"
"`PyModule_New` を使って通常のモジュールオブジェクトを生成します。\n"
"モジュールの名前は定義ではなく *spec* から取得され、これによって拡張モジュー"
"ルが動的にモジュール階層における位置を調整できたり、シンボリックリンクを通し"
"て同一のモジュール定義を共有しつつ別の名前でインポートできたりします。"

#: ../../c-api/module.rst:329
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:type:`PyModule_Type` のインスタンスである必要はあり"
"ません。\n"
"インポートに関連する属性の設定と取得ができる限りは、どんな型でも使えます。\n"
"しかし、 ``PyModuleDef`` が *NULL* でない ``m_traverse``, ``m_clear``, "
"``m_free`` 、もしくはゼロでない ``m_size`` 、もしくは ``Py_mod_create`` 以外"
"のスロットを持つ場合は、 ``PyModule_Type`` インスタンスのみが返されるでしょ"
"う。"

#: ../../c-api/module.rst:338
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 ""
"モジュールを *実行する* ときに呼ばれる関数を指定します。\n"
"これはPythonモジュールのコードを実行するのと同等です:\n"
"この関数はたいていはクラスと定数をモジュールにします。\n"
"この関数のシグネチャは以下です:"

#: ../../c-api/module.rst:345
msgid ""
"If multiple ``Py_mod_exec`` slots are specified, they are processed in the "
"order they appear in the *m_slots* array."
msgstr ""
"複数の ``Py_mod_exec`` スロットが設定されていた場合は、 *m_slots* 配列に現れ"
"た順に処理されていきます。"

#: ../../c-api/module.rst:348
msgid "See :PEP:`489` for more details on multi-phase initialization."
msgstr "多段階初期化についてより詳しくは :PEP:`489` を見てください。"

#: ../../c-api/module.rst:351
msgid "Low-level module creation functions"
msgstr "低水準モジュール作成関数"

#: ../../c-api/module.rst:353
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 ""
"以下の関数は、多段階初期化を使うときに裏側で呼び出されます。\n"
"例えばモジュールオブジェクトを動的に生成するときに、これらの関数を直接使えま"
"す。\n"
"``PyModule_FromDefAndSpec`` および ``PyModule_ExecDef`` のどちらも、呼び出し"
"た後にはモジュールが完全に初期化されていなければなりません。"

#: ../../c-api/module.rst:360
msgid ""
"Create a new module object, given the definition in *module* and the "
"ModuleSpec *spec*.  This behaves like :c:func:`PyModule_FromDefAndSpec2` "
"with *module_api_version* set to :const:`PYTHON_API_VERSION`."
msgstr ""
"*module* と ModuleSpec オブジェクトの *spec* で定義されたとおりに新しいモ"
"ジュールオブジェクトを生成します。\n"
"この関数は、 :c:func:`PyModule_FromDefAndSpec2` 関数の *module_api_version* "
"に :const:`PYTHON_API_VERSION` を指定した時とおなじようにふるまいます。"

#: ../../c-api/module.rst:368
msgid ""
"Create a new module object, given the definition in *module* 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 ""
"APIバージョンを *module_api_version* として、 *module* と ModuleSpec オブジェ"
"クトの *spec* で定義されたとおりに新しいモジュールオブジェクトを生成しま"
"す。\n"
"もし指定されたバージョンが実行しているインタープリターのバージョンと異なる場"
"合は、 :exc:`RuntimeWarning` を発生させます。"

#: ../../c-api/module.rst:375
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:func:`PyModule_FromDefAndSpec` を利用する"
"べきです。\n"
"この関数は、この関数の必要性を理解しているときにだけ利用してください。"

#: ../../c-api/module.rst:382
msgid "Process any execution slots (:c:data:`Py_mod_exec`) given in *def*."
msgstr ""
"*def* で与えられた任意の実行スロット (:c:data:`Py_mod_exec`) を実行します。"

#: ../../c-api/module.rst:388
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 ""
"*module* の docstring を *docstring* に設定します。\n"
"この関数は、 ``PyModuleDef`` から ``PyModule_Create`` もしくは "
"``PyModule_FromDefAndSpec`` を使ってモジュールを生成するときに自動的に呼び出"
"されます。"

#: ../../c-api/module.rst:397
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 ""
"終端が *NULL* になっている *functions* 配列にある関数を *module* に追加しま"
"す。\n"
":c:type:`PyMethodDef` 構造体の個々のエントリについては PyMethodDef の説明を参"
"照してください (モジュールの名前空間が共有されていないので、 C で実装されたモ"
"ジュールレベル \"関数\" はたいていモジュールを1つ目の引数として受け取り、 "
"Python クラスのインスタンスメソッドに似た形にします)。\n"
"この関数は、 ``PyModuleDef`` から ``PyModule_Create`` もしくは "
"``PyModule_FromDefAndSpec`` を使ってモジュールを生成するときに自動的に呼び出"
"されます。"

#: ../../c-api/module.rst:409
msgid "Support functions"
msgstr "サポート関数"

#: ../../c-api/module.rst:411
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 ""
"モジュールの初期化関数 (一段階初期化を使う場合) 、あるいはモジュールの実行ス"
"ロットから呼び出される関数 (多段階初期化を使う場合) は次の関数を使うと、モ"
"ジュールの state の初期化を簡単にできます:"

#: ../../c-api/module.rst:418
msgid ""
"Add an object to *module* as *name*.  This is a convenience function which "
"can be used from the module's initialization function.  This steals a "
"reference to *value*.  Return ``-1`` on error, ``0`` on success."
msgstr ""
"*module* にオブジェクトを *name* として追加します。\n"
"この関数はモジュールの初期化関数から利用される便利関数です。\n"
"これは *value* への参照を盗みます。\n"
"エラーのときには ``-1`` を、成功したときには ``0`` を返します。"

#: ../../c-api/module.rst:424
msgid ""
"Add an integer constant to *module* as *name*.  This convenience function "
"can be used from the module's initialization function. Return ``-1`` on "
"error, ``0`` on success."
msgstr ""
"*module* に整数定数を *name* として追加します。この便宜関数はモジュールの初期"
"化関数から利用されています。エラーのときには ``-1`` を、成功したときには "
"``0`` を返します。"

#: ../../c-api/module.rst:431
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`` on error, ``0`` on success."
msgstr ""
"*module* に文字列定数を *name* として追加します。\n"
"この便利関数はモジュールの初期化関数から利用されています。\n"
"文字列 *value* は *NULL* 終端されていなければなりません。\n"
"エラーのときには ``-1`` を、成功したときには ``0`` を返します。"

#: ../../c-api/module.rst:438
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`` on "
"error, ``0`` on success."
msgstr ""
"*module* に int 定数を追加します。名前と値は *macro* から取得されます。例え"
"ば、 ``PyModule_AddIntMacro(module, AF_INET)`` とすると、 *AF_INET* という名"
"前の int 型定数を *AF_INET* の値で *module* に追加します。エラー時には "
"``-1`` を、成功時には ``0`` を返します。"

#: ../../c-api/module.rst:446
msgid "Add a string constant to *module*."
msgstr "文字列定数を *module* に追加します。"

#: ../../c-api/module.rst:450
msgid "Module lookup"
msgstr "モジュール検索"

#: ../../c-api/module.rst:452
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 ""
"一段階初期化は、現在のインタプリタのコンテキストから探せるシングルトンのモ"
"ジュールを生成します。\n"
"これによって、後からモジュール定義への参照だけでモジュールオブジェクトが取得"
"できます。"

#: ../../c-api/module.rst:456
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:461
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 ""
"現在のインタプリタの *def* から作られたモジュールオブジェクトを返します。この"
"メソッドの前提条件として、前もって :c:func:`PyState_AddModule` でインタプリタ"
"の state にモジュールオブジェクトを連結しておくことを要求します。対応するモ"
"ジュールオブジェクトが見付からない、もしくは事前にインタプリタの state に連結"
"されていない場合は、 *NULL* を返します。"

#: ../../c-api/module.rst:468
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 ""
"関数に渡されたモジュールオブジェクトを、インタプリタの state に連結します。こ"
"の関数を使うことで :c:func:`PyState_FindModule` からモジュールオブジェクトに"
"アクセスできるようになります。"

#: ../../c-api/module.rst:471
msgid "Only effective on modules created using single-phase initialization."
msgstr "一段階初期化を使って作成されたモジュールにのみ有効です。"

#: ../../c-api/module.rst:477
msgid ""
"Removes the module object created from *def* from the interpreter state."
msgstr ""
"*def* から作られたモジュールオブジェクトをインタプリタ state から削除します。"