exceptions.po

# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2001-2022, Python Software Foundation
# This file is distributed under the same license as the Python package.
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
#
# Translators:
# Rafael Fontenelle <rffontenelle@gmail.com>, 2022
#
#, fuzzy
msgid ""
msgstr ""
"Project-Id-Version: Python 3.10\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2022-12-30 14:59+0000\n"
"PO-Revision-Date: 2022-11-05 17:21+0000\n"
"Last-Translator: Rafael Fontenelle <rffontenelle@gmail.com>, 2022\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/exceptions.rst:8
msgid "Exception Handling"
msgstr "例外処理"

#: ../../c-api/exceptions.rst:10
msgid ""
"The functions described in this chapter will let you handle and raise Python "
"exceptions.  It is important to understand some of the basics of Python "
"exception handling.  It works somewhat like the POSIX :c:data:`errno` "
"variable: there is a global indicator (per thread) of the last error that "
"occurred.  Most C API functions don't clear this on success, but will set it "
"to indicate the cause of the error on failure.  Most C API functions also "
"return an error indicator, usually ``NULL`` if they are supposed to return a "
"pointer, or ``-1`` if they return an integer (exception: the ``PyArg_*`` "
"functions return ``1`` for success and ``0`` for failure)."
msgstr ""
"この章で説明する関数を使うと、 Python の例外の処理や例外の送出ができるように"
"なります。 Python の例外処理の基本をいくらか理解することが大切です。例外は "
"POSIX :c:data:`errno` 変数にやや似た機能を果たします: 発生した中で最も新しい"
"エラーの (スレッド毎の) グローバルなインジケータがあります。実行に成功した場"
"合にはほとんどの C API 関数がこれをクリアしませんが、失敗したときにはエラーの"
"原因を示すために設定します。ほとんどの C API 関数はエラーインジケータも返し、"
"通常は関数がポインタを返すことになっている場合は ``NULL`` であり、関数が整数"
"を返す場合は ``-1`` です。(例外: ``PyArg_*`` 関数は実行に成功したときに "
"``1`` を返し、失敗したときに ``0`` を返します)."

#: ../../c-api/exceptions.rst:20
msgid ""
"Concretely, the error indicator consists of three object pointers: the "
"exception's type, the exception's value, and the traceback object.  Any of "
"those pointers can be ``NULL`` if non-set (although some combinations are "
"forbidden, for example you can't have a non-``NULL`` traceback if the "
"exception type is ``NULL``)."
msgstr ""
"具体的には、エラーインジケータは、例外の型、例外の値、トレースバックオブジェ"
"クトの３つのオブジェクトポインタで構成されます。これらのポインタはどれでも、"
"設定されない場合は ``NULL`` になりえます（ただし、いくつかの組み合わせは禁止"
"されており、例えば、例外の型が ``NULL`` の場合は、トレースバックは非 "
"``NULL`` の値になりません）"

#: ../../c-api/exceptions.rst:26
msgid ""
"When a function must fail because some function it called failed, it "
"generally doesn't set the error indicator; the function it called already "
"set it.  It is responsible for either handling the error and clearing the "
"exception or returning after cleaning up any resources it holds (such as "
"object references or memory allocations); it should *not* continue normally "
"if it is not prepared to handle the error.  If returning due to an error, it "
"is important to indicate to the caller that an error has been set.  If the "
"error is not handled or carefully propagated, additional calls into the "
"Python/C API may not behave as intended and may fail in mysterious ways."
msgstr ""
"ある関数が呼び出した関数がいくつか失敗したために、その関数が失敗しなければな"
"らないとき、一般的にエラーインジケータを設定しません。呼び出した関数がすでに"
"設定しています。エラーを処理して例外をクリアするか、あるいは (オブジェクト参"
"照またはメモリ割り当てのような)それが持つどんなリソースも取り除いた後に戻るか"
"のどちらか一方を行う責任があります。エラーを処理する準備をしていなければ、普"
"通に続けるべきでは *ありません*。エラーのために戻る場合は、エラーが設定されて"
"いると呼び出し元に知らせることが大切です。エラーが処理されていない場合または"
"丁寧に伝えられている場合には、Python/C APIのさらなる呼び出しは意図した通りに"
"は動かない可能性があり、不可解な形で失敗するかもしれません。"

#: ../../c-api/exceptions.rst:37
msgid ""
"The error indicator is **not** the result of :func:`sys.exc_info()`. The "
"former corresponds to an exception that is not yet caught (and is therefore "
"still propagating), while the latter returns an exception after it is caught "
"(and has therefore stopped propagating)."
msgstr ""
"エラー識別子は :func:`sys.exc_info()` の結果 **ではありません**。エラー識別子"
"はまだ捕捉されていない例外 (したがってまだ伝播します) に対応しているのに対"
"し、 sys.exc_info() の結果は捕捉された後の例外を返します (したがってもう伝播"
"しません)。"

#: ../../c-api/exceptions.rst:44
msgid "Printing and clearing"
msgstr "出力とクリア"

#: ../../c-api/exceptions.rst:49
msgid ""
"Clear the error indicator.  If the error indicator is not set, there is no "
"effect."
msgstr ""
"エラーインジケータをクリアします。エラーインジケータが設定されていないなら"
"ば、効果はありません。"

#: ../../c-api/exceptions.rst:55
msgid ""
"Print a standard traceback to ``sys.stderr`` and clear the error indicator. "
"**Unless** the error is a ``SystemExit``, in that case no traceback is "
"printed and the Python process will exit with the error code specified by "
"the ``SystemExit`` instance."
msgstr ""
"標準のトレースバックを ``sys.stderr`` に出力し、エラーインジケータをクリアし"
"ます。\n"
"ただし、エラーが ``SystemExit`` **である場合を除いて** です。\n"
"その場合、トレースバックは出力されず、 Python プロセスは ``SystemExit`` イン"
"スタンスで指定されたエラーコードで終了します。"

#: ../../c-api/exceptions.rst:60
msgid ""
"Call this function **only** when the error indicator is set.  Otherwise it "
"will cause a fatal error!"
msgstr ""
"エラーインジケータが設定されているときに **だけ**、この関数を呼び出してくださ"
"い。\n"
"それ以外の場合、致命的なエラーを引き起こすでしょう!"

#: ../../c-api/exceptions.rst:63
msgid ""
"If *set_sys_last_vars* is nonzero, the variables :data:`sys.last_type`, :"
"data:`sys.last_value` and :data:`sys.last_traceback` will be set to the "
"type, value and traceback of the printed exception, respectively."
msgstr ""
"*set_sys_last_vars* が非ゼロであれば、 :data:`sys.last_type`, :data:`sys."
"last_value`, :data:`sys.last_traceback` 変数が、表示される例外のタイプ、値、"
"トレースバックそれぞれに反映されます。"

#: ../../c-api/exceptions.rst:70
msgid "Alias for ``PyErr_PrintEx(1)``."
msgstr "``PyErr_PrintEx(1)`` のエイリアスです。"

#: ../../c-api/exceptions.rst:75
msgid ""
"Call :func:`sys.unraisablehook` using the current exception and *obj* "
"argument."
msgstr "現在の例外と *obj* 引数で :func:`sys.unraisablehook` を呼び出します。"

#: ../../c-api/exceptions.rst:78
msgid ""
"This utility function prints a warning message to ``sys.stderr`` when an "
"exception has been set but it is impossible for the interpreter to actually "
"raise the exception.  It is used, for example, when an exception occurs in "
"an :meth:`__del__` method."
msgstr ""
"例外が設定されているがインタプリタが実際に例外を発生させることができないとき"
"に、このユーティリティ関数は警告メッセージを ``sys.stderr`` へ出力します。例"
"えば、例外が :meth:`__del__` メソッドで発生したときに使われます。"

#: ../../c-api/exceptions.rst:83
msgid ""
"The function is called with a single argument *obj* that identifies the "
"context in which the unraisable exception occurred. If possible, the repr of "
"*obj* will be printed in the warning message."
msgstr ""
"発生させられない例外が起きたコンテキストを指し示す単一の引数 *obj* で関数が呼"
"び出されます。\n"
"可能な場合は、 *obj* の repr 文字列が警告メッセージに出力されます。"

#: ../../c-api/exceptions.rst:87
msgid "An exception must be set when calling this function."
msgstr "この関数を呼び出すときには、例外がセットされていなければなりません。"

#: ../../c-api/exceptions.rst:91
msgid "Raising exceptions"
msgstr "例外の送出"

#: ../../c-api/exceptions.rst:93
msgid ""
"These functions help you set the current thread's error indicator. For "
"convenience, some of these functions will always return a ``NULL`` pointer "
"for use in a ``return`` statement."
msgstr ""
"以下の関数は、現在のスレッドのエラーインジケータの設定を補助します。利便性の"
"ため、これらの関数のいくつかは、 ``return`` 文で利用できるように常に "
"``NULL`` ポインタを返します。"

#: ../../c-api/exceptions.rst:100
msgid ""
"This is the most common way to set the error indicator.  The first argument "
"specifies the exception type; it is normally one of the standard exceptions, "
"e.g. :c:data:`PyExc_RuntimeError`.  You need not increment its reference "
"count. The second argument is an error message; it is decoded from "
"``'utf-8'``."
msgstr ""
"これはエラーインジケータを設定するための最も一般的な方法です。第一引数は例外"
"の型を指定します。通常は標準例外の一つ、例えば :c:data:`PyExc_RuntimeError` "
"です。その参照カウントを増加させる必要はありません。第二引数はエラーメッセー"
"ジで、 ``'utf-8'`` からデコードされます。"

#: ../../c-api/exceptions.rst:108
msgid ""
"This function is similar to :c:func:`PyErr_SetString` but lets you specify "
"an arbitrary Python object for the \"value\" of the exception."
msgstr ""
"この関数は :c:func:`PyErr_SetString` に似ていますが、例外の \"値(value)\" と"
"して任意のPythonオブジェクトを指定することができます。"

#: ../../c-api/exceptions.rst:114
msgid ""
"This function sets the error indicator and returns ``NULL``.  *exception* "
"should be a Python exception class.  The *format* and subsequent parameters "
"help format the error message; they have the same meaning and values as in :"
"c:func:`PyUnicode_FromFormat`. *format* is an ASCII-encoded string."
msgstr ""
"この関数はエラーインジケータを設定し ``NULL`` を返します。 *exception* は"
"Python例外クラスであるべきです。 *format* と以降の引数はエラーメッセージを作"
"るためのもので, :c:func:`PyUnicode_FromFormat` の引数と同じ意味を持っていま"
"す。 *format* は ASCII エンコードされた文字列です。"

#: ../../c-api/exceptions.rst:123
msgid ""
"Same as :c:func:`PyErr_Format`, but taking a :c:type:`va_list` argument "
"rather than a variable number of arguments."
msgstr ""
":c:func:`PyErr_Format` と同じですが、可変長引数の代わりに :c:type:`va_list` "
"引数を受け取ります。"

#: ../../c-api/exceptions.rst:131
msgid "This is a shorthand for ``PyErr_SetObject(type, Py_None)``."
msgstr "これは ``PyErr_SetObject(type, Py_None)`` を省略したものです。"

#: ../../c-api/exceptions.rst:136
msgid ""
"This is a shorthand for ``PyErr_SetString(PyExc_TypeError, message)``, where "
"*message* indicates that a built-in operation was invoked with an illegal "
"argument.  It is mostly for internal use."
msgstr ""
"これは ``PyErr_SetString(PyExc_TypeError, message)`` を省略したもので、ここ"
"で *message* は組み込み操作が不正な引数で呼び出されたということを表していま"
"す。主に内部で使用するためのものです。"

#: ../../c-api/exceptions.rst:143
msgid ""
"This is a shorthand for ``PyErr_SetNone(PyExc_MemoryError)``; it returns "
"``NULL`` so an object allocation function can write ``return "
"PyErr_NoMemory();`` when it runs out of memory."
msgstr ""
"これは ``PyErr_SetNone(PyExc_MemoryError)`` を省略したもので、``NULL`` を返し"
"ます。したがって、メモリ不足になったとき、オブジェクト割り当て関数は "
"``return PyErr_NoMemory();`` と書くことができます。"

#: ../../c-api/exceptions.rst:152
msgid ""
"This is a convenience function to raise an exception when a C library "
"function has returned an error and set the C variable :c:data:`errno`.  It "
"constructs a tuple object whose first item is the integer :c:data:`errno` "
"value and whose second item is the corresponding error message (gotten from :"
"c:func:`strerror`), and then calls ``PyErr_SetObject(type, object)``.  On "
"Unix, when the :c:data:`errno` value is :const:`EINTR`, indicating an "
"interrupted system call, this calls :c:func:`PyErr_CheckSignals`, and if "
"that set the error indicator, leaves it set to that.  The function always "
"returns ``NULL``, so a wrapper function around a system call can write "
"``return PyErr_SetFromErrno(type);`` when the system call returns an error."
msgstr ""
"Cライブラリ関数がエラーを返してC変数 :c:data:`errno` を設定したときに、これは"
"例外を発生させるために便利な関数です。第一要素が整数 :c:data:`errno` 値で、第"
"二要素が (:c:func:`strerror` から得られる)対応するエラーメッセージであるタプ"
"ルオブジェクトを構成します。それから、 ``PyErr_SetObject(type, object)`` を呼"
"び出します。 Unixでは、 :c:data:`errno` 値が :const:`EINTR` であるとき、すな"
"わち割り込まれたシステムコールを表しているとき、これは :c:func:"
"`PyErr_CheckSignals` を呼び出し、それがエラーインジケータを設定した場合は設定"
"されたままにしておきます。関数は常に ``NULL`` を返します。したがって、システ"
"ムコールがエラーを返したとき、システムコールのラッパー関数は ``return "
"PyErr_SetFromErrno(type);`` と書くことができます。"

#: ../../c-api/exceptions.rst:166
msgid ""
"Similar to :c:func:`PyErr_SetFromErrno`, with the additional behavior that "
"if *filenameObject* is not ``NULL``, it is passed to the constructor of "
"*type* as a third parameter.  In the case of :exc:`OSError` exception, this "
"is used to define the :attr:`filename` attribute of the exception instance."
msgstr ""
":c:func:`PyErr_SetFromErrno` に似ていますが、 *filenameObject* が ``NULL`` で"
"ない場合に、 *type* のコンストラクタに第三引数として渡すというふるまいが追加"
"されています。\n"
":exc:`OSError` 例外の場合では、 *filenameObject* が例外インスタンスの :attr:"
"`filename` 属性を定義するのに使われます。"

#: ../../c-api/exceptions.rst:175
msgid ""
"Similar to :c:func:`PyErr_SetFromErrnoWithFilenameObject`, but takes a "
"second filename object, for raising errors when a function that takes two "
"filenames fails."
msgstr ""
":c:func:`PyErr_SetFromErrnoWithFilenameObject` に似てますが、ファイル名を2つ"
"取る関数が失敗したときに例外を送出するために、2つ目のファイル名オブジェクトを"
"受け取ります。"

#: ../../c-api/exceptions.rst:184
msgid ""
"Similar to :c:func:`PyErr_SetFromErrnoWithFilenameObject`, but the filename "
"is given as a C string.  *filename* is decoded from the :term:`filesystem "
"encoding and error handler`."
msgstr ""
":c:func:`PyErr_SetFromErrnoWithFilenameObject` に似ていますが、ファイル名は "
"C 文字列として与えられます。\n"
"*filename* は :term:`ファイルシステムのエンコーディングとエラーハンドラ "
"<filesystem encoding and error handler>` でデコードされます。"

#: ../../c-api/exceptions.rst:191
msgid ""
"This is a convenience function to raise :exc:`WindowsError`. If called with "
"*ierr* of ``0``, the error code returned by a call to :c:func:`GetLastError` "
"is used instead.  It calls the Win32 function :c:func:`FormatMessage` to "
"retrieve the Windows description of error code given by *ierr* or :c:func:"
"`GetLastError`, then it constructs a tuple object whose first item is the "
"*ierr* value and whose second item is the corresponding error message "
"(gotten from :c:func:`FormatMessage`), and then calls "
"``PyErr_SetObject(PyExc_WindowsError, object)``. This function always "
"returns ``NULL``."
msgstr ""
"これは :exc:`WindowsError` を発生させるために便利な関数です。 ``0`` の "
"*ierr* とともに呼び出された場合、 :c:func:`GetLastError` が返すエラーコードが"
"代りに使われます。 *ierr* あるいは :c:func:`GetLastError` によって与えられる"
"エラーコードのWindows用の説明を取り出すために、Win32関数 :c:func:"
"`FormatMessage` を呼び出します。それから、第一要素が *ierr* 値で第二要素が(:"
"c:func:`FormatMessage` から得られる) 対応するエラーメッセージであるタプルオブ"
"ジェクトを構成します。そして、 ``PyErr_SetObject(PyExc_WindowsError, "
"object)`` を呼び出します。この関数は常に ``NULL`` を返します。"

#: ../../c-api/exceptions.rst:200 ../../c-api/exceptions.rst:208
#: ../../c-api/exceptions.rst:217 ../../c-api/exceptions.rst:225
#: ../../c-api/exceptions.rst:234 ../../c-api/exceptions.rst:243
msgid ":ref:`Availability <availability>`: Windows."
msgstr ":ref:`利用可能な環境 <availability>`: Windows 。"

#: ../../c-api/exceptions.rst:205
msgid ""
"Similar to :c:func:`PyErr_SetFromWindowsErr`, with an additional parameter "
"specifying the exception type to be raised."
msgstr ""
":c:func:`PyErr_SetFromWindowsErr` に似ていますが、送出する例外の型を指定する"
"引数が追加されています。"

#: ../../c-api/exceptions.rst:213
msgid ""
"Similar to :c:func:`PyErr_SetFromWindowsErrWithFilenameObject`, but the "
"filename is given as a C string.  *filename* is decoded from the filesystem "
"encoding (:func:`os.fsdecode`)."
msgstr ""
":c:func:`PyErr_SetFromWindowsErrWithFilenameObject` に似ていますが、ファイル"
"名は C 文字列として与えられます。\n"
"*filename* はファイルシステムのエンコーディング (:func:`os.fsdecode`) でデ"
"コードされます。"

#: ../../c-api/exceptions.rst:222
msgid ""
"Similar to :c:func:`PyErr_SetFromWindowsErrWithFilenameObject`, with an "
"additional parameter specifying the exception type to be raised."
msgstr ""
":c:func:`PyErr_SetFromWindowsErrWithFilenameObject` に似ていますが、送出する"
"例外の型を指定する引数が追加されています。"

#: ../../c-api/exceptions.rst:230
msgid ""
"Similar to :c:func:`PyErr_SetExcFromWindowsErrWithFilenameObject`, but "
"accepts a second filename object."
msgstr ""
":c:func:`PyErr_SetExcFromWindowsErrWithFilenameObject` に似てますが、2つ目の"
"ファイル名オブジェクトを受け取ります。"

#: ../../c-api/exceptions.rst:240
msgid ""
"Similar to :c:func:`PyErr_SetFromWindowsErrWithFilename`, with an additional "
"parameter specifying the exception type to be raised."
msgstr ""
":c:func:`PyErr_SetFromWindowsErrWithFilename` に似ていますが、送出する例外の"
"型を指定する引数が追加されています。"

#: ../../c-api/exceptions.rst:248
msgid ""
"This is a convenience function to raise :exc:`ImportError`. *msg* will be "
"set as the exception's message string. *name* and *path*, both of which can "
"be ``NULL``, will be set as the :exc:`ImportError`'s respective ``name`` and "
"``path`` attributes."
msgstr ""
":exc:`ImportError` を簡単に送出するための関数です。 *msg* は例外のメッセージ"
"文字列としてセットされます。 *name* と *path* はどちらも ``NULL`` にしてよ"
"く、それぞれ :exc:`ImportError` の ``name`` 属性と ``path`` 属性としてセット"
"されます。"

#: ../../c-api/exceptions.rst:258
msgid ""
"Much like :c:func:`PyErr_SetImportError` but this function allows for "
"specifying a subclass of :exc:`ImportError` to raise."
msgstr ""
":c:func:`PyErr_SetImportError` とよく似ていますが、この関数は送出する例外とし"
"て、 :exc:`ImportError` のサブクラスを指定できます。"

#: ../../c-api/exceptions.rst:266
msgid ""
"Set file, line, and offset information for the current exception.  If the "
"current exception is not a :exc:`SyntaxError`, then it sets additional "
"attributes, which make the exception printing subsystem think the exception "
"is a :exc:`SyntaxError`."
msgstr ""
"現在の例外のファイル、行、オフセットの情報をセットします。\n"
"現在の例外が :exc:`SyntaxError` でない場合は、例外を表示するサブシステムが、"
"例外が :exc:`SyntaxError` であると思えるように属性を追加します。"

#: ../../c-api/exceptions.rst:276
msgid ""
"Like :c:func:`PyErr_SyntaxLocationObject`, but *filename* is a byte string "
"decoded from the :term:`filesystem encoding and error handler`."
msgstr ""
":c:func:`PyErr_SyntaxLocationObject` と似ていますが、 *filename* は :term:`"
"ファイルシステムのエンコーディングとエラーハンドラ <filesystem encoding and "
"error handler>` でデコードされたバイト文字列です。"

#: ../../c-api/exceptions.rst:284
msgid ""
"Like :c:func:`PyErr_SyntaxLocationEx`, but the *col_offset* parameter is "
"omitted."
msgstr ""
":c:func:`PyErr_SyntaxLocationEx` と似ていますが、 *col_offset* 引数が除去され"
"ています。"

#: ../../c-api/exceptions.rst:290
msgid ""
"This is a shorthand for ``PyErr_SetString(PyExc_SystemError, message)``, "
"where *message* indicates that an internal operation (e.g. a Python/C API "
"function) was invoked with an illegal argument.  It is mostly for internal "
"use."
msgstr ""
"``PyErr_SetString(PyExc_SystemError, message)`` を省略したものです。ここで "
"*message* は内部操作(例えば、Python/C API関数)が不正な引数とともに呼び出され"
"たということを示しています。主に内部で使用するためのものです。"

#: ../../c-api/exceptions.rst:297
msgid "Issuing warnings"
msgstr "警告"

#: ../../c-api/exceptions.rst:299
msgid ""
"Use these functions to issue warnings from C code.  They mirror similar "
"functions exported by the Python :mod:`warnings` module.  They normally "
"print a warning message to *sys.stderr*; however, it is also possible that "
"the user has specified that warnings are to be turned into errors, and in "
"that case they will raise an exception.  It is also possible that the "
"functions raise an exception because of a problem with the warning "
"machinery. The return value is ``0`` if no exception is raised, or ``-1`` if "
"an exception is raised.  (It is not possible to determine whether a warning "
"message is actually printed, nor what the reason is for the exception; this "
"is intentional.)  If an exception is raised, the caller should do its normal "
"exception handling (for example, :c:func:`Py_DECREF` owned references and "
"return an error value)."
msgstr ""
"以下の関数を使い、 C コードで起きた警告を報告します。\n"
"Python の :mod:`warnings` モジュールで公開されている同様の関数とよく似てま"
"す。\n"
"これらの関数は通常警告メッセージを *sys.stderr* へ出力しますが、ユーザが警告"
"をエラーへ変更するように指定することもでき、その場合は、関数は例外を送出しま"
"す。\n"
"警告機構がもつ問題のためにその関数が例外を送出するということも有り得ます。\n"
"例外が送出されない場合は戻り値は ``0`` で、例外が送出された場合は ``-1`` で"
"す。\n"
"(警告メッセージが実際に出力されるか、およびその例外の原因が何かについては判断"
"できません; これは意図的なものです。)\n"
"例外が送出された場合、呼び出し元は通常の例外処理を行います (例えば、保持して"
"いた参照に対し :c:func:`Py_DECREF` を行い、エラー値を返します)。"

#: ../../c-api/exceptions.rst:314
msgid ""
"Issue a warning message.  The *category* argument is a warning category (see "
"below) or ``NULL``; the *message* argument is a UTF-8 encoded string.  "
"*stack_level* is a positive number giving a number of stack frames; the "
"warning will be issued from the  currently executing line of code in that "
"stack frame.  A *stack_level* of 1 is the function calling :c:func:"
"`PyErr_WarnEx`, 2 is  the function above that, and so forth."
msgstr ""
"警告メッセージを発行します。 *category* 引数は警告カテゴリ(以下を参照) かまた"
"は ``NULL`` で、 *message* 引数は UTF-8 エンコードされた文字列です。 "
"*stacklevel* はスタックフレームの数を示す正の整数です; 警告はそのスタックフ"
"レームの中の実行している行から発行されます。 *stacklevel* が 1 だと :c:func:"
"`PyErr_WarnEx` を呼び出している関数が、2 だとその上の関数が Warning の発行元"
"になります。"

#: ../../c-api/exceptions.rst:321
msgid ""
"Warning categories must be subclasses of :c:data:`PyExc_Warning`; :c:data:"
"`PyExc_Warning` is a subclass of :c:data:`PyExc_Exception`; the default "
"warning category is :c:data:`PyExc_RuntimeWarning`. The standard Python "
"warning categories are available as global variables whose names are "
"enumerated at :ref:`standardwarningcategories`."
msgstr ""
"警告カテゴリは :c:data:`PyExc_Warning` のサブクラスでなければなりません。 :c:"
"data:`PyExc_Warning` は :c:data:`PyExc_Exception` のサブクラスです。\n"
"デフォルトの警告カテゴリは :c:data:`PyExc_RuntimeWarning` です。\n"
"標準の Python 警告カテゴリは、 :ref:`standardwarningcategories` で名前が列挙"
"されているグローバル変数として利用可能です。"

#: ../../c-api/exceptions.rst:327
msgid ""
"For information about warning control, see the documentation for the :mod:"
"`warnings` module and the :option:`-W` option in the command line "
"documentation.  There is no C API for warning control."
msgstr ""
"警告をコントロールするための情報については、 :mod:`warnings` モジュールのド"
"キュメンテーションとコマンドライン・ドキュメンテーションの :option:`-W` オプ"
"ションを参照してください。警告コントロールのためのC APIはありません。"

#: ../../c-api/exceptions.rst:334
msgid ""
"Issue a warning message with explicit control over all warning attributes.  "
"This is a straightforward wrapper around the Python function :func:`warnings."
"warn_explicit`; see there for more information.  The *module* and *registry* "
"arguments may be set to ``NULL`` to get the default effect described there."
msgstr ""
"すべての警告の属性を明示的に制御した警告メッセージを出します。これは Python "
"関数 :func:`warnings.warn_explicit` の直接的なラッパーで、さらに情報を得るに"
"はそちらを参照してください。そこに説明されているデフォルトの効果を得るため"
"に、 *module* と *registry* 引数は ``NULL`` に設定することができます。"

#: ../../c-api/exceptions.rst:345
msgid ""
"Similar to :c:func:`PyErr_WarnExplicitObject` except that *message* and "
"*module* are UTF-8 encoded strings, and *filename* is decoded from the :term:"
"`filesystem encoding and error handler`."
msgstr ""
":c:func:`PyErr_WarnExplicitObject` に似ていますが、 *message* と *module* が "
"UTF-8 エンコードされた文字列であるところが異なり、 *filename* は :term:`ファ"
"イルシステムのエンコーディングとエラーハンドラ <filesystem encoding and "
"error handler>` でデコードされます。"

#: ../../c-api/exceptions.rst:352
msgid ""
"Function similar to :c:func:`PyErr_WarnEx`, but use :c:func:"
"`PyUnicode_FromFormat` to format the warning message.  *format* is an ASCII-"
"encoded string."
msgstr ""
":c:func:`PyErr_WarnEx` に似たような関数ですが、警告メッセージをフォーマットす"
"るのに :c:func:`PyUnicode_FromFormat` を使用します。 *format* は ASCII にエン"
"コードされた文字列です。"

#: ../../c-api/exceptions.rst:361
msgid ""
"Function similar to :c:func:`PyErr_WarnFormat`, but *category* is :exc:"
"`ResourceWarning` and it passes *source* to :func:`warnings.WarningMessage`."
msgstr ""
":c:func:`PyErr_WarnFormat` に似た関数ですが、*category* は :exc:"
"`ResourceWarning` になり、*source* は :func:`warnings.WarningMessage` に渡さ"
"れます。"

#: ../../c-api/exceptions.rst:368
msgid "Querying the error indicator"
msgstr "エラーインジケータの問い合わせ"

#: ../../c-api/exceptions.rst:372
msgid ""
"Test whether the error indicator is set.  If set, return the exception "
"*type* (the first argument to the last call to one of the ``PyErr_Set*`` "
"functions or to :c:func:`PyErr_Restore`).  If not set, return ``NULL``.  You "
"do not own a reference to the return value, so you do not need to :c:func:"
"`Py_DECREF` it."
msgstr ""
"エラーインジケータが設定されているかテストします。設定されている場合は、例外"
"の *型* (``PyErr_Set*`` 関数の一つあるいは :c:func:`PyErr_Restore` への最も新"
"しい呼び出しに対する第一引数)を返します。設定されていない場合は ``NULL`` を返"
"します。あなたは戻り値への参照を持っていませんので、それに :c:func:"
"`Py_DECREF` する必要はありません。"

#: ../../c-api/exceptions.rst:378
msgid "The caller must hold the GIL."
msgstr "呼び出し側はGILを獲得しなければなりません。"

#: ../../c-api/exceptions.rst:382
msgid ""
"Do not compare the return value to a specific exception; use :c:func:"
"`PyErr_ExceptionMatches` instead, shown below.  (The comparison could easily "
"fail since the exception may be an instance instead of a class, in the case "
"of a class exception, or it may be a subclass of the expected exception.)"
msgstr ""
"戻り値を特定の例外と比較しないでください。その代わりに、下に示す :c:func:"
"`PyErr_ExceptionMatches` を使ってください。(比較は簡単に失敗するでしょう。な"
"ぜなら、例外はクラスではなくインスタンスかもしれないし、あるいは、クラス例外"
"の場合は期待される例外のサブクラスかもしれないからです。)"

#: ../../c-api/exceptions.rst:390
msgid ""
"Equivalent to ``PyErr_GivenExceptionMatches(PyErr_Occurred(), exc)``.  This "
"should only be called when an exception is actually set; a memory access "
"violation will occur if no exception has been raised."
msgstr ""
"``PyErr_GivenExceptionMatches(PyErr_Occurred(), exc)`` と同じ。例外が実際に設"
"定されたときにだけ、これを呼び出だすべきです。例外が発生していないならば、メ"
"モリアクセス違反が起きるでしょう。"

#: ../../c-api/exceptions.rst:397
msgid ""
"Return true if the *given* exception matches the exception type in *exc*.  "
"If *exc* is a class object, this also returns true when *given* is an "
"instance of a subclass.  If *exc* is a tuple, all exception types in the "
"tuple (and recursively in subtuples) are searched for a match."
msgstr ""
"例外 *given* が *exc* の例外型と適合する場合に真を返します。\n"
"*exc* がクラスオブジェクトである場合も、 *given* がサブクラスのインスタンスで"
"あるときに真を返します。\n"
"*exc* がタプルの場合は、タプルにある (およびそのサブタプルに再帰的にある) す"
"べての例外型が適合するか調べられます。"

#: ../../c-api/exceptions.rst:405
msgid ""
"Retrieve the error indicator into three variables whose addresses are "
"passed. If the error indicator is not set, set all three variables to "
"``NULL``.  If it is set, it will be cleared and you own a reference to each "
"object retrieved.  The value and traceback object may be ``NULL`` even when "
"the type object is not."
msgstr ""
"エラーインジケータをアドレスを渡す三つの変数の中へ取り出します。エラーインジ"
"ケータが設定されていない場合は、三つすべての変数を ``NULL`` に設定します。エ"
"ラーインジケータが設定されている場合はクリアされ、あなたは取り出されたそれぞ"
"れのオブジェクトへの参照を持つことになります。型オブジェクトが ``NULL`` でな"
"いときでさえ、その値とトレースバックオブジェクトは ``NULL`` かもしれません。"

#: ../../c-api/exceptions.rst:412
msgid ""
"This function is normally only used by code that needs to catch exceptions "
"or by code that needs to save and restore the error indicator temporarily, e."
"g.::"
msgstr ""
"通常、この関数は例外を捕捉する必要のあるコードや、エラーインジケータを一時的"
"に保存して復元する必要のあるコードでのみ使います。"

#: ../../c-api/exceptions.rst:427
msgid ""
"Set  the error indicator from the three objects.  If the error indicator is "
"already set, it is cleared first.  If the objects are ``NULL``, the error "
"indicator is cleared.  Do not pass a ``NULL`` type and non-``NULL`` value or "
"traceback.  The exception type should be a class.  Do not pass an invalid "
"exception type or value. (Violating these rules will cause subtle problems "
"later.)  This call takes away a reference to each object: you must own a "
"reference to each object before the call and after the call you no longer "
"own these references.  (If you don't understand this, don't use this "
"function.  I warned you.)"
msgstr ""
"三つのオブジェクトからエラーインジケータを設定します。エラーインジケータがす"
"でに設定されている場合は、最初にクリアされます。オブジェクトが ``NULL`` なら"
"ば、エラーインジケータがクリアされます。``NULL`` のtypeと非 ``NULL`` のvalue"
"あるいは tracebackを渡してはいけません。例外の型(type)はクラスであるべきで"
"す。無効な例外の型(type)あるいは値(value)を渡してはいけません。(これらの規則"
"を破ると後で気付きにくい問題の原因となるでしょう。) この呼び出しはそれぞれの"
"オブジェクトへの参照を取り除きます: あなたは呼び出しの前にそれぞれのオブジェ"
"クトへの参照を持たなければならないのであり、また呼び出しの後にはもはやこれら"
"の参照を持っていません。(これを理解していない場合は、この関数を使ってはいけま"
"せん。注意しておきます。)"

#: ../../c-api/exceptions.rst:439
msgid ""
"This function is normally only used by code that needs to save and restore "
"the error indicator temporarily.  Use :c:func:`PyErr_Fetch` to save the "
"current error indicator."
msgstr ""
"通常、この関数はエラーインジケータを一時的に保存し復元する必要のあるコードで"
"のみ使います。\n"
"現在のエラーインジケータを保存するためには :c:func:`PyErr_Fetch` を使ってくだ"
"さい。"

#: ../../c-api/exceptions.rst:446
msgid ""
"Under certain circumstances, the values returned by :c:func:`PyErr_Fetch` "
"below can be \"unnormalized\", meaning that ``*exc`` is a class object but "
"``*val`` is not an instance of the  same class.  This function can be used "
"to instantiate the class in that case.  If the values are already "
"normalized, nothing happens. The delayed normalization is implemented to "
"improve performance."
msgstr ""
"ある状況では、以下の :c:func:`PyErr_Fetch` が返す値は \"正規化されていない\" "
"可能性があります。つまり、 ``*exc`` はクラスオブジェクトだが ``*val`` は同じ"
"クラスのインスタンスではないという意味です。この関数はそのような場合にそのク"
"ラスをインスタンス化するために使われます。その値がすでに正規化されている場合"
"は何も起きません。遅延正規化はパフォーマンスを改善するために実装されていま"
"す。"

#: ../../c-api/exceptions.rst:454
msgid ""
"This function *does not* implicitly set the ``__traceback__`` attribute on "
"the exception value. If setting the traceback appropriately is desired, the "
"following additional snippet is needed::"
msgstr ""
"この関数は例外値に暗黙的に ``__traceback__`` 属性を設定 *しません* 。\n"
"トレースバックを適切に設定する必要がある場合は、次の追加のコード片が必要で"
"す::"

#: ../../c-api/exceptions.rst:465
msgid ""
"Retrieve the exception info, as known from ``sys.exc_info()``.  This refers "
"to an exception that was *already caught*, not to an exception that was "
"freshly raised.  Returns new references for the three objects, any of which "
"may be ``NULL``.  Does not modify the exception info state."
msgstr ""
"``sys.exc_info()`` で得られる例外情報を取得します。\n"
"これは *既に捕まえた* 例外を参照するもので、新たに送出された例外への参照は"
"持っていません。\n"
"新しい3つのオブジェクトへの参照を返しますが、その中には ``NULL`` があるかもし"
"れません。この関数は例外情報の状態を変更しません。"

#: ../../c-api/exceptions.rst:472
msgid ""
"This function is not normally used by code that wants to handle exceptions. "
"Rather, it can be used when code needs to save and restore the exception "
"state temporarily.  Use :c:func:`PyErr_SetExcInfo` to restore or clear the "
"exception state."
msgstr ""
"この関数は、通常は例外を扱うコードでは使用されません。正確に言うと、これは例"
"外の状態を一時的に保存し、元に戻す必要があるコードで使用することができます。"
"例外の状態を元に戻す、もしくはクリアするには :c:func:`PyErr_SetExcInfo` を"
"使ってください。"

#: ../../c-api/exceptions.rst:482
msgid ""
"Set the exception info, as known from ``sys.exc_info()``.  This refers to an "
"exception that was *already caught*, not to an exception that was freshly "
"raised.  This function steals the references of the arguments. To clear the "
"exception state, pass ``NULL`` for all three arguments. For general rules "
"about the three arguments, see :c:func:`PyErr_Restore`."
msgstr ""
"``sys.exc_info()`` で得られる例外情報を設定します。\n"
"これは *既に捕まえた* 例外を参照するもので、新たに送出された例外への参照は"
"持っていません。\n"
"この関数は引数への参照を盗みます。\n"
"例外の状態をクリアしたい場合は、3 つ全ての引数に ``NULL`` を渡してくださ"
"い。\n"
"3 つの引数についての一般的な規則は、 :c:func:`PyErr_Restore` を参照してくださ"
"い。"

#: ../../c-api/exceptions.rst:490
msgid ""
"This function is not normally used by code that wants to handle exceptions. "
"Rather, it can be used when code needs to save and restore the exception "
"state temporarily.  Use :c:func:`PyErr_GetExcInfo` to read the exception "
"state."
msgstr ""
"この関数は、通常は例外を扱うコードでは使用されません。正確に言うと、これは例"
"外の状態を一時的に保存し、元に戻す必要があるコードで使用することができます。"
"例外の状態を取得するには :c:func:`PyErr_GetExcInfo` を使ってください。"

#: ../../c-api/exceptions.rst:499
msgid "Signal Handling"
msgstr "シグナルハンドリング"

#: ../../c-api/exceptions.rst:509
msgid "This function interacts with Python's signal handling."
msgstr ""

#: ../../c-api/exceptions.rst:511
msgid ""
"If the function is called from the main thread and under the main Python "
"interpreter, it checks whether a signal has been sent to the processes and "
"if so, invokes the corresponding signal handler.  If the :mod:`signal` "
"module is supported, this can invoke a signal handler written in Python."
msgstr ""

#: ../../c-api/exceptions.rst:516
msgid ""
"The function attempts to handle all pending signals, and then returns ``0``. "
"However, if a Python signal handler raises an exception, the error indicator "
"is set and the function returns ``-1`` immediately (such that other pending "
"signals may not have been handled yet: they will be on the next :c:func:"
"`PyErr_CheckSignals()` invocation)."
msgstr ""

#: ../../c-api/exceptions.rst:522
msgid ""
"If the function is called from a non-main thread, or under a non-main Python "
"interpreter, it does nothing and returns ``0``."
msgstr ""

#: ../../c-api/exceptions.rst:525
msgid ""
"This function can be called by long-running C code that wants to be "
"interruptible by user requests (such as by pressing Ctrl-C)."
msgstr ""

#: ../../c-api/exceptions.rst:529
msgid ""
"The default Python signal handler for :const:`SIGINT` raises the :exc:"
"`KeyboardInterrupt` exception."
msgstr ""

#: ../../c-api/exceptions.rst:540
msgid ""
"Simulate the effect of a :const:`SIGINT` signal arriving. This is equivalent "
"to ``PyErr_SetInterruptEx(SIGINT)``."
msgstr ""

#: ../../c-api/exceptions.rst:544 ../../c-api/exceptions.rst:571
msgid ""
"This function is async-signal-safe.  It can be called without the :term:"
"`GIL` and from a C signal handler."
msgstr ""

#: ../../c-api/exceptions.rst:554
msgid ""
"Simulate the effect of a signal arriving. The next time :c:func:"
"`PyErr_CheckSignals` is called,  the Python signal handler for the given "
"signal number will be called."
msgstr ""
"シグナルが到達した効果をシミュレートします。\n"
"次に :c:func:`PyErr_CheckSignals` が呼ばれたとき、与えられたシグナル番号用の "
"Python のシグナルハンドラが呼び出されます。"

#: ../../c-api/exceptions.rst:558
msgid ""
"This function can be called by C code that sets up its own signal handling "
"and wants Python signal handlers to be invoked as expected when an "
"interruption is requested (for example when the user presses Ctrl-C to "
"interrupt an operation)."
msgstr ""

#: ../../c-api/exceptions.rst:563
msgid ""
"If the given signal isn't handled by Python (it was set to :data:`signal."
"SIG_DFL` or :data:`signal.SIG_IGN`), it will be ignored."
msgstr ""
"与えられたシグナルが Python に対処されなかった (:data:`signal.SIG_DFL` また"
"は :data:`signal.SIG_IGN` に設定されていた) 場合、無視されます。"

#: ../../c-api/exceptions.rst:566
msgid ""
"If *signum* is outside of the allowed range of signal numbers, ``-1`` is "
"returned.  Otherwise, ``0`` is returned.  The error indicator is never "
"changed by this function."
msgstr ""

#: ../../c-api/exceptions.rst:579
msgid ""
"This utility function specifies a file descriptor to which the signal number "
"is written as a single byte whenever a signal is received. *fd* must be non-"
"blocking. It returns the previous such file descriptor."
msgstr ""
"このユーティリティ関数は、シグナルを受け取ったときにシグナル番号をバイトとし"
"て書き込むファイル記述子を指定します。\n"
"*fd* はノンブロッキングでなければなりません。\n"
"この関数は、1つ前のファイル記述子を返します。"

#: ../../c-api/exceptions.rst:583
msgid ""
"The value ``-1`` disables the feature; this is the initial state. This is "
"equivalent to :func:`signal.set_wakeup_fd` in Python, but without any error "
"checking.  *fd* should be a valid file descriptor.  The function should only "
"be called from the main thread."
msgstr ""
"値 ``-1`` を渡すと、この機能を無効にします; これが初期状態です。\n"
"この関数は Python の :func:`signal.set_wakeup_fd` と同等ですが、どんなエラー"
"チェックも行いません。\n"
"*fd* は有効なファイル記述子であるべきです。\n"
"この関数はメインスレッドからのみ呼び出されるべきです。"

#: ../../c-api/exceptions.rst:588
msgid "On Windows, the function now also supports socket handles."
msgstr "Windowsで、この関数はソケットハンドルをサポートするようになりました。"

#: ../../c-api/exceptions.rst:593
msgid "Exception Classes"
msgstr "例外クラス"

#: ../../c-api/exceptions.rst:597
msgid ""
"This utility function creates and returns a new exception class. The *name* "
"argument must be the name of the new exception, a C string of the form "
"``module.classname``.  The *base* and *dict* arguments are normally "
"``NULL``. This creates a class object derived from :exc:`Exception` "
"(accessible in C as :c:data:`PyExc_Exception`)."
msgstr ""
"このユーティリティ関数は新しい例外クラスを作成して返します。 *name* 引数は新"
"しい例外の名前、 ``module.classname`` 形式の C文字列でなければならない。 "
"*base* と *dict* 引数は通常 ``NULL`` です。これはすべての例外のためのルート、"
"組み込み名 :exc:`Exception` (Cでは :c:data:`PyExc_Exception` としてアクセス可"
"能)をルートとして派生したクラスオブジェクトを作成します。"

#: ../../c-api/exceptions.rst:603
msgid ""
"The :attr:`__module__` attribute of the new class is set to the first part "
"(up to the last dot) of the *name* argument, and the class name is set to "
"the last part (after the last dot).  The *base* argument can be used to "
"specify alternate base classes; it can either be only one class or a tuple "
"of classes. The *dict* argument can be used to specify a dictionary of class "
"variables and methods."
msgstr ""
"新しいクラスの :attr:`__module__` 属性は *name* 引数の前半部分(最後のドットま"
"で)に設定され、クラス名は後半部分(最後のドットの後)に設定されます。 *base* 引"
"数は代わりのベースクラスを指定するために使えます; 一つのクラスでも、クラスの"
"タプルでも構いません。 *dict* 引数はクラス変数とメソッドの辞書を指定するため"
"に使えます。"

#: ../../c-api/exceptions.rst:612
msgid ""
"Same as :c:func:`PyErr_NewException`, except that the new exception class "
"can easily be given a docstring: If *doc* is non-``NULL``, it will be used "
"as the docstring for the exception class."
msgstr ""
":c:func:`PyErr_NewException` とほぼ同じですが、新しい例外クラスに簡単に "
"docstring を設定できます。 *doc* が ``NULL`` で無い場合、それが例外クラスの "
"docstring になります。"

#: ../../c-api/exceptions.rst:620
msgid "Exception Objects"
msgstr "例外オブジェクト"

#: ../../c-api/exceptions.rst:624
msgid ""
"Return the traceback associated with the exception as a new reference, as "
"accessible from Python through :attr:`__traceback__`.  If there is no "
"traceback associated, this returns ``NULL``."
msgstr ""
"Python で :attr:`__traceback__` 属性からアクセスできるものと同じ、例外に関す"
"る traceback の新しい参照を返します。関係する traceback が無い場合は、 "
"``NULL`` を返します。"

#: ../../c-api/exceptions.rst:631
msgid ""
"Set the traceback associated with the exception to *tb*.  Use ``Py_None`` to "
"clear it."
msgstr ""
"その例外に関する traceback に *tb* をセットします。クリアするには "
"``Py_None`` を使用してください。"

#: ../../c-api/exceptions.rst:637
msgid ""
"Return the context (another exception instance during whose handling *ex* "
"was raised) associated with the exception as a new reference, as accessible "
"from Python through :attr:`__context__`.  If there is no context associated, "
"this returns ``NULL``."
msgstr ""
"Python で :attr:`__context__` 属性からアクセスできるものと同じ、例外に関する"
"コンテキスト (*ex* が送出されたときに処理していた別の例外インスタンス) の新し"
"い参照を返します。関係するコンテキストが無い場合は、 ``NULL`` を返します。"

#: ../../c-api/exceptions.rst:645
msgid ""
"Set the context associated with the exception to *ctx*.  Use ``NULL`` to "
"clear it.  There is no type check to make sure that *ctx* is an exception "
"instance. This steals a reference to *ctx*."
msgstr ""
"例外に関するコンテキストに *ctx* をセットします。クリアするには ``NULL`` を使"
"用してください。*ctx* が例外インスタンスかどうかを確かめる型チェックは行われ"
"ません。これは *ctx* への参照を盗みます。"

#: ../../c-api/exceptions.rst:652
msgid ""
"Return the cause (either an exception instance, or :const:`None`, set by "
"``raise ... from ...``) associated with the exception as a new reference, as "
"accessible from Python through :attr:`__cause__`."
msgstr ""
"Python で :attr:`__cause__` 属性からアクセスできるものと同じ、例外に関する原"
"因 (``raise ... from ...`` によってセットされる例外インスタンス、もしくは :"
"const:`None`) の新しい参照を返します。"

#: ../../c-api/exceptions.rst:659
msgid ""
"Set the cause associated with the exception to *cause*.  Use ``NULL`` to "
"clear it.  There is no type check to make sure that *cause* is either an "
"exception instance or :const:`None`.  This steals a reference to *cause*."
msgstr ""
"例外に関係する原因に *cause* をセットします。\n"
"クリアするには ``NULL`` を使用してください。\n"
"*cause* が例外インスタンスか :const:`None` のどちらかであることを確かめる型"
"チェックは行われません。\n"
"これは *cause* への参照を盗みます。"

#: ../../c-api/exceptions.rst:663
msgid ""
":attr:`__suppress_context__` is implicitly set to ``True`` by this function."
msgstr ""
"この関数によって暗黙的に :attr:`__suppress_context__` に ``True`` がセットさ"
"れます。"

#: ../../c-api/exceptions.rst:669
msgid "Unicode Exception Objects"
msgstr "Unicode 例外オブジェクト"

#: ../../c-api/exceptions.rst:671
msgid ""
"The following functions are used to create and modify Unicode exceptions "
"from C."
msgstr ""
"以下の関数は C言語から Unicode 例外を作ったり修正したりするために利用します。"

#: ../../c-api/exceptions.rst:675
msgid ""
"Create a :class:`UnicodeDecodeError` object with the attributes *encoding*, "
"*object*, *length*, *start*, *end* and *reason*. *encoding* and *reason* are "
"UTF-8 encoded strings."
msgstr ""
"*encoding*, *object*, *length*, *start*, *end*, *reason* 属性をもった :class:"
"`UnicodeDecodeError` オブジェクトを作成します。 *encoding* および *reason* "
"は UTF-8 エンコードされた文字列です。"

#: ../../c-api/exceptions.rst:681
msgid ""
"Create a :class:`UnicodeEncodeError` object with the attributes *encoding*, "
"*object*, *length*, *start*, *end* and *reason*. *encoding* and *reason* are "
"UTF-8 encoded strings."
msgstr ""
"*encoding*, *object*, *length*, *start*, *end*, *reason* 属性を持った :class:"
"`UnicodeEncodeError` オブジェクトを作成します。 *encoding* および *reason* "
"は UTF-8 エンコードされた文字列です。"

#: ../../c-api/exceptions.rst:685 ../../c-api/exceptions.rst:695
msgid "3.11"
msgstr "3.11"

#: ../../c-api/exceptions.rst:687
msgid ""
"``Py_UNICODE`` is deprecated since Python 3.3. Please migrate to "
"``PyObject_CallFunction(PyExc_UnicodeEncodeError, \"sOnns\", ...)``."
msgstr ""

#: ../../c-api/exceptions.rst:692
msgid ""
"Create a :class:`UnicodeTranslateError` object with the attributes *object*, "
"*length*, *start*, *end* and *reason*. *reason* is a UTF-8 encoded string."
msgstr ""
"*object*, *length*, *start*, *end*, *reason* 属性を持った :class:"
"`UnicodeTranslateError` オブジェクトを作成します。\n"
"*reason* は UTF-8 エンコードされた文字列です。"

#: ../../c-api/exceptions.rst:697
msgid ""
"``Py_UNICODE`` is deprecated since Python 3.3. Please migrate to "
"``PyObject_CallFunction(PyExc_UnicodeTranslateError, \"Onns\", ...)``."
msgstr ""

#: ../../c-api/exceptions.rst:703
msgid "Return the *encoding* attribute of the given exception object."
msgstr "与えられた例外オブジェクトの *encoding* 属性を返します。"

#: ../../c-api/exceptions.rst:709
msgid "Return the *object* attribute of the given exception object."
msgstr "与えられた例外オブジェクトの *object* 属性を返します。"

#: ../../c-api/exceptions.rst:715
msgid ""
"Get the *start* attribute of the given exception object and place it into "
"*\\*start*.  *start* must not be ``NULL``.  Return ``0`` on success, ``-1`` "
"on failure."
msgstr ""
"渡された例外オブジェクトから *start* 属性を取得して *\\*start* に格納します。"
"*start* は ``NULL`` であってはなりません。成功したら ``0`` を、失敗したら "
"``-1`` を返します。"

#: ../../c-api/exceptions.rst:723
msgid ""
"Set the *start* attribute of the given exception object to *start*.  Return "
"``0`` on success, ``-1`` on failure."
msgstr ""
"渡された例外オブジェクトの *start* 属性を *start* に設定します。成功したら "
"``0`` を、失敗したら ``-1`` を返します。"

#: ../../c-api/exceptions.rst:730
msgid ""
"Get the *end* attribute of the given exception object and place it into "
"*\\*end*.  *end* must not be ``NULL``.  Return ``0`` on success, ``-1`` on "
"failure."
msgstr ""
"渡された例外オブジェクトから *end* 属性を取得して *\\*end* に格納します。"
"*end* は ``NULL`` であってはなりません。成功したら ``0`` を、失敗したら "
"``-1`` を返します。"

#: ../../c-api/exceptions.rst:738
msgid ""
"Set the *end* attribute of the given exception object to *end*.  Return "
"``0`` on success, ``-1`` on failure."
msgstr ""
"渡された例外オブジェクトの *end* 属性を *end* に設定します。成功したら ``0`` "
"を、失敗したら ``-1`` を返します。"

#: ../../c-api/exceptions.rst:745
msgid "Return the *reason* attribute of the given exception object."
msgstr "渡された例外オブジェクトの *reason* 属性を返します。"

#: ../../c-api/exceptions.rst:751
msgid ""
"Set the *reason* attribute of the given exception object to *reason*.  "
"Return ``0`` on success, ``-1`` on failure."
msgstr ""
"渡された例外オブジェクトの *reason* 属性を *reason* に設定します。成功したら "
"``0`` を、失敗したら ``-1`` を返します。"

#: ../../c-api/exceptions.rst:758
msgid "Recursion Control"
msgstr "再帰の管理"

#: ../../c-api/exceptions.rst:760
msgid ""
"These two functions provide a way to perform safe recursive calls at the C "
"level, both in the core and in extension modules.  They are needed if the "
"recursive code does not necessarily invoke Python code (which tracks its "
"recursion depth automatically). They are also not needed for *tp_call* "
"implementations because the :ref:`call protocol <call>` takes care of "
"recursion handling."
msgstr ""

#: ../../c-api/exceptions.rst:769
msgid "Marks a point where a recursive C-level call is about to be performed."
msgstr "C レベルの再帰呼び出しをしようとしているところに印を付けます。"

#: ../../c-api/exceptions.rst:771
msgid ""
"If :const:`USE_STACKCHECK` is defined, this function checks if the OS stack "
"overflowed using :c:func:`PyOS_CheckStack`.  In this is the case, it sets a :"
"exc:`MemoryError` and returns a nonzero value."
msgstr ""
":const:`USE_STACKCHECK` が定義されている場合、 OS のスタックがオーバーフロー"
"がしたかどうかを :c:func:`PyOS_CheckStack` を使ってチェックします。もしオー"
"バーフローしているなら、 :exc:`MemoryError` をセットしゼロでない値を返しま"
"す。"

#: ../../c-api/exceptions.rst:775
msgid ""
"The function then checks if the recursion limit is reached.  If this is the "
"case, a :exc:`RecursionError` is set and a nonzero value is returned. "
"Otherwise, zero is returned."
msgstr ""
"次にこの関数は再帰の上限に達していないかをチェックします。\n"
"上限に達している場合、 :exc:`RecursionError` をセットしゼロでない値を返しま"
"す。\n"
"そうでない場合はゼロを返します。"

#: ../../c-api/exceptions.rst:779
msgid ""
"*where* should be a UTF-8 encoded string such as ``\" in instance check\"`` "
"to be concatenated to the :exc:`RecursionError` message caused by the "
"recursion depth limit."
msgstr ""
"*where* は ``\" in instance check\"`` のような UTF-8 エンコードされた文字列に"
"して、再帰の深さの限界に達したことで送出される :exc:`RecursionError` のメッ"
"セージに連結できるようにすべきです。"

#: ../../c-api/exceptions.rst:783 ../../c-api/exceptions.rst:791
msgid "This function is now also available in the limited API."
msgstr ""

#: ../../c-api/exceptions.rst:788
msgid ""
"Ends a :c:func:`Py_EnterRecursiveCall`.  Must be called once for each "
"*successful* invocation of :c:func:`Py_EnterRecursiveCall`."
msgstr ""
":c:func:`Py_EnterRecursiveCall` を終了させます。 :c:func:"
"`Py_EnterRecursiveCall` の *成功した* 呼び出しに対し 1 回呼ばなければなりませ"
"ん。"

#: ../../c-api/exceptions.rst:794
msgid ""
"Properly implementing :c:member:`~PyTypeObject.tp_repr` for container types "
"requires special recursion handling.  In addition to protecting the stack, :"
"c:member:`~PyTypeObject.tp_repr` also needs to track objects to prevent "
"cycles.  The following two functions facilitate this functionality.  "
"Effectively, these are the C equivalent to :func:`reprlib.recursive_repr`."
msgstr ""
"コンテナ型に対し :c:member:`~PyTypeObject.tp_repr` を適切に実装するには、特殊"
"な再帰の処理が求められます。スタックの防護に加え、 :c:member:`~PyTypeObject."
"tp_repr` は循環処理を避けるためにオブジェクトを辿っていく必要があります。次"
"の 2 つの関数はその機能を容易にします。実質的には、これらは :func:`reprlib."
"recursive_repr` と同等な C の実装です。"

#: ../../c-api/exceptions.rst:802
msgid ""
"Called at the beginning of the :c:member:`~PyTypeObject.tp_repr` "
"implementation to detect cycles."
msgstr ""
"循環処理を検知するために、 :c:member:`~PyTypeObject.tp_repr` の実装の先頭で呼"
"び出します。"

#: ../../c-api/exceptions.rst:805
msgid ""
"If the object has already been processed, the function returns a positive "
"integer.  In that case the :c:member:`~PyTypeObject.tp_repr` implementation "
"should return a string object indicating a cycle.  As examples, :class:"
"`dict` objects return ``{...}`` and :class:`list` objects return ``[...]``."
msgstr ""
"そのオブジェクトが既に処理されたものだった場合、この関数は正の整数を返しま"
"す。その場合、 :c:member:`~PyTypeObject.tp_repr` の実装は、循環を示す文字列オ"
"ブジェクトを返すべきです。例えば、 :class:`dict` オブジェクトは ``{...}`` を"
"返しますし、  :class:`list` オブジェクトは ``[...]`` を返します。"

#: ../../c-api/exceptions.rst:811
msgid ""
"The function will return a negative integer if the recursion limit is "
"reached.  In that case the :c:member:`~PyTypeObject.tp_repr` implementation "
"should typically return ``NULL``."
msgstr ""
"再帰回数の上限に達した場合は、この関数は負の整数を返します。この場合、 :c:"
"member:`~PyTypeObject.tp_repr` の実装は一般的には ``NULL`` を返すべきです。"

#: ../../c-api/exceptions.rst:815
msgid ""
"Otherwise, the function returns zero and the :c:member:`~PyTypeObject."
"tp_repr` implementation can continue normally."
msgstr ""
"それ以外の場合は、関数はゼロを返し、 :c:member:`~PyTypeObject.tp_repr` の実装"
"は通常どおり処理を続けてかまいません。"

#: ../../c-api/exceptions.rst:820
msgid ""
"Ends a :c:func:`Py_ReprEnter`.  Must be called once for each invocation of :"
"c:func:`Py_ReprEnter` that returns zero."
msgstr ""
":c:func:`Py_ReprEnter` を終了させます。 0 を返した :c:func:`Py_ReprEnter` の"
"呼び出しに対し 1 回呼ばなければなりません。"

#: ../../c-api/exceptions.rst:827
msgid "Standard Exceptions"
msgstr "標準例外"

#: ../../c-api/exceptions.rst:829
msgid ""
"All standard Python exceptions are available as global variables whose names "
"are ``PyExc_`` followed by the Python exception name.  These have the type :"
"c:expr:`PyObject*`; they are all class objects.  For completeness, here are "
"all the variables:"
msgstr ""
"``PyExc_`` の後ろにPythonの例外名が続く名前をもつグローバル変数として、すべて"
"の標準Python例外が利用可能です。これらは型 :c:expr:`PyObject*` を持ち、すべて"
"クラスオブジェクトです。完璧を期するために、すべての変数を以下に列挙します:"

#: ../../c-api/exceptions.rst:890 ../../c-api/exceptions.rst:1023
#: ../../c-api/exceptions.rst:1068
msgid "C Name"
msgstr "C名"

#: ../../c-api/exceptions.rst:890 ../../c-api/exceptions.rst:1068
msgid "Python Name"
msgstr "Python名"

#: ../../c-api/exceptions.rst:890 ../../c-api/exceptions.rst:1023
#: ../../c-api/exceptions.rst:1068
msgid "Notes"
msgstr "注釈"

#: ../../c-api/exceptions.rst:892
msgid ":c:data:`PyExc_BaseException`"
msgstr ":c:data:`PyExc_BaseException`"

#: ../../c-api/exceptions.rst:892
msgid ":exc:`BaseException`"
msgstr ":exc:`BaseException`"

#: ../../c-api/exceptions.rst:892 ../../c-api/exceptions.rst:894
#: ../../c-api/exceptions.rst:896 ../../c-api/exceptions.rst:942
#: ../../c-api/exceptions.rst:954
msgid "[1]_"
msgstr "[1]_"

#: ../../c-api/exceptions.rst:894
msgid ":c:data:`PyExc_Exception`"
msgstr ":c:data:`PyExc_Exception`"

#: ../../c-api/exceptions.rst:894
msgid ":exc:`Exception`"
msgstr ":exc:`Exception`"

#: ../../c-api/exceptions.rst:896
msgid ":c:data:`PyExc_ArithmeticError`"
msgstr ":c:data:`PyExc_ArithmeticError`"

#: ../../c-api/exceptions.rst:896
msgid ":exc:`ArithmeticError`"
msgstr ":exc:`ArithmeticError`"

#: ../../c-api/exceptions.rst:898
msgid ":c:data:`PyExc_AssertionError`"
msgstr ":c:data:`PyExc_AssertionError`"

#: ../../c-api/exceptions.rst:898
msgid ":exc:`AssertionError`"
msgstr ":exc:`AssertionError`"

#: ../../c-api/exceptions.rst:900
msgid ":c:data:`PyExc_AttributeError`"
msgstr ":c:data:`PyExc_AttributeError`"

#: ../../c-api/exceptions.rst:900
msgid ":exc:`AttributeError`"
msgstr ":exc:`AttributeError`"

#: ../../c-api/exceptions.rst:902
msgid ":c:data:`PyExc_BlockingIOError`"
msgstr ":c:data:`PyExc_BlockingIOError`"

#: ../../c-api/exceptions.rst:902
msgid ":exc:`BlockingIOError`"
msgstr ":exc:`BlockingIOError`"

#: ../../c-api/exceptions.rst:904
msgid ":c:data:`PyExc_BrokenPipeError`"
msgstr ":c:data:`PyExc_BrokenPipeError`"

#: ../../c-api/exceptions.rst:904
msgid ":exc:`BrokenPipeError`"
msgstr ":exc:`BrokenPipeError`"

#: ../../c-api/exceptions.rst:906
msgid ":c:data:`PyExc_BufferError`"
msgstr ":c:data:`PyExc_BufferError`"

#: ../../c-api/exceptions.rst:906
msgid ":exc:`BufferError`"
msgstr ":exc:`BufferError`"

#: ../../c-api/exceptions.rst:908
msgid ":c:data:`PyExc_ChildProcessError`"
msgstr ":c:data:`PyExc_ChildProcessError`"

#: ../../c-api/exceptions.rst:908
msgid ":exc:`ChildProcessError`"
msgstr ":exc:`ChildProcessError`"

#: ../../c-api/exceptions.rst:910
msgid ":c:data:`PyExc_ConnectionAbortedError`"
msgstr ":c:data:`PyExc_ConnectionAbortedError`"

#: ../../c-api/exceptions.rst:910
msgid ":exc:`ConnectionAbortedError`"
msgstr ":exc:`ConnectionAbortedError`"

#: ../../c-api/exceptions.rst:912
msgid ":c:data:`PyExc_ConnectionError`"
msgstr ":c:data:`PyExc_ConnectionError`"

#: ../../c-api/exceptions.rst:912
msgid ":exc:`ConnectionError`"
msgstr ":exc:`ConnectionError`"

#: ../../c-api/exceptions.rst:914
msgid ":c:data:`PyExc_ConnectionRefusedError`"
msgstr ":c:data:`PyExc_ConnectionRefusedError`"

#: ../../c-api/exceptions.rst:914
msgid ":exc:`ConnectionRefusedError`"
msgstr ":exc:`ConnectionRefusedError`"

#: ../../c-api/exceptions.rst:916
msgid ":c:data:`PyExc_ConnectionResetError`"
msgstr ":c:data:`PyExc_ConnectionResetError`"

#: ../../c-api/exceptions.rst:916
msgid ":exc:`ConnectionResetError`"
msgstr ":exc:`ConnectionResetError`"

#: ../../c-api/exceptions.rst:918
msgid ":c:data:`PyExc_EOFError`"
msgstr ":c:data:`PyExc_EOFError`"

#: ../../c-api/exceptions.rst:918
msgid ":exc:`EOFError`"
msgstr ":exc:`EOFError`"

#: ../../c-api/exceptions.rst:920
msgid ":c:data:`PyExc_FileExistsError`"
msgstr ":c:data:`PyExc_FileExistsError`"

#: ../../c-api/exceptions.rst:920
msgid ":exc:`FileExistsError`"
msgstr ":exc:`FileExistsError`"

#: ../../c-api/exceptions.rst:922
msgid ":c:data:`PyExc_FileNotFoundError`"
msgstr ":c:data:`PyExc_FileNotFoundError`"

#: ../../c-api/exceptions.rst:922
msgid ":exc:`FileNotFoundError`"
msgstr ":exc:`FileNotFoundError`"

#: ../../c-api/exceptions.rst:924
msgid ":c:data:`PyExc_FloatingPointError`"
msgstr ":c:data:`PyExc_FloatingPointError`"

#: ../../c-api/exceptions.rst:924
msgid ":exc:`FloatingPointError`"
msgstr ":exc:`FloatingPointError`"

#: ../../c-api/exceptions.rst:926
msgid ":c:data:`PyExc_GeneratorExit`"
msgstr ":c:data:`PyExc_GeneratorExit`"

#: ../../c-api/exceptions.rst:926
msgid ":exc:`GeneratorExit`"
msgstr ":exc:`GeneratorExit`"

#: ../../c-api/exceptions.rst:928
msgid ":c:data:`PyExc_ImportError`"
msgstr ":c:data:`PyExc_ImportError`"

#: ../../c-api/exceptions.rst:928
msgid ":exc:`ImportError`"
msgstr ":exc:`ImportError`"

#: ../../c-api/exceptions.rst:930
msgid ":c:data:`PyExc_IndentationError`"
msgstr ":c:data:`PyExc_IndentationError`"

#: ../../c-api/exceptions.rst:930
msgid ":exc:`IndentationError`"
msgstr ":exc:`IndentationError`"

#: ../../c-api/exceptions.rst:932
msgid ":c:data:`PyExc_IndexError`"
msgstr ":c:data:`PyExc_IndexError`"

#: ../../c-api/exceptions.rst:932
msgid ":exc:`IndexError`"
msgstr ":exc:`IndexError`"

#: ../../c-api/exceptions.rst:934
msgid ":c:data:`PyExc_InterruptedError`"
msgstr ":c:data:`PyExc_InterruptedError`"

#: ../../c-api/exceptions.rst:934
msgid ":exc:`InterruptedError`"
msgstr ":exc:`InterruptedError`"

#: ../../c-api/exceptions.rst:936
msgid ":c:data:`PyExc_IsADirectoryError`"
msgstr ":c:data:`PyExc_IsADirectoryError`"

#: ../../c-api/exceptions.rst:936
msgid ":exc:`IsADirectoryError`"
msgstr ":exc:`IsADirectoryError`"

#: ../../c-api/exceptions.rst:938
msgid ":c:data:`PyExc_KeyError`"
msgstr ":c:data:`PyExc_KeyError`"

#: ../../c-api/exceptions.rst:938
msgid ":exc:`KeyError`"
msgstr ":exc:`KeyError`"

#: ../../c-api/exceptions.rst:940
msgid ":c:data:`PyExc_KeyboardInterrupt`"
msgstr ":c:data:`PyExc_KeyboardInterrupt`"

#: ../../c-api/exceptions.rst:940
msgid ":exc:`KeyboardInterrupt`"
msgstr ":exc:`KeyboardInterrupt`"

#: ../../c-api/exceptions.rst:942
msgid ":c:data:`PyExc_LookupError`"
msgstr ":c:data:`PyExc_LookupError`"

#: ../../c-api/exceptions.rst:942
msgid ":exc:`LookupError`"
msgstr ":exc:`LookupError`"

#: ../../c-api/exceptions.rst:944
msgid ":c:data:`PyExc_MemoryError`"
msgstr ":c:data:`PyExc_MemoryError`"

#: ../../c-api/exceptions.rst:944
msgid ":exc:`MemoryError`"
msgstr ":exc:`MemoryError`"

#: ../../c-api/exceptions.rst:946
msgid ":c:data:`PyExc_ModuleNotFoundError`"
msgstr ":c:data:`PyExc_ModuleNotFoundError`"

#: ../../c-api/exceptions.rst:946
msgid ":exc:`ModuleNotFoundError`"
msgstr ":exc:`ModuleNotFoundError`"

#: ../../c-api/exceptions.rst:948
msgid ":c:data:`PyExc_NameError`"
msgstr ":c:data:`PyExc_NameError`"

#: ../../c-api/exceptions.rst:948
msgid ":exc:`NameError`"
msgstr ":exc:`NameError`"

#: ../../c-api/exceptions.rst:950
msgid ":c:data:`PyExc_NotADirectoryError`"
msgstr ":c:data:`PyExc_NotADirectoryError`"

#: ../../c-api/exceptions.rst:950
msgid ":exc:`NotADirectoryError`"
msgstr ":exc:`NotADirectoryError`"

#: ../../c-api/exceptions.rst:952
msgid ":c:data:`PyExc_NotImplementedError`"
msgstr ":c:data:`PyExc_NotImplementedError`"

#: ../../c-api/exceptions.rst:952
msgid ":exc:`NotImplementedError`"
msgstr ":exc:`NotImplementedError`"

#: ../../c-api/exceptions.rst:954
msgid ":c:data:`PyExc_OSError`"
msgstr ":c:data:`PyExc_OSError`"

#: ../../c-api/exceptions.rst:954
msgid ":exc:`OSError`"
msgstr ":exc:`OSError`"

#: ../../c-api/exceptions.rst:956
msgid ":c:data:`PyExc_OverflowError`"
msgstr ":c:data:`PyExc_OverflowError`"

#: ../../c-api/exceptions.rst:956
msgid ":exc:`OverflowError`"
msgstr ":exc:`OverflowError`"

#: ../../c-api/exceptions.rst:958
msgid ":c:data:`PyExc_PermissionError`"
msgstr ":c:data:`PyExc_PermissionError`"

#: ../../c-api/exceptions.rst:958
msgid ":exc:`PermissionError`"
msgstr ":exc:`PermissionError`"

#: ../../c-api/exceptions.rst:960
msgid ":c:data:`PyExc_ProcessLookupError`"
msgstr ":c:data:`PyExc_ProcessLookupError`"

#: ../../c-api/exceptions.rst:960
msgid ":exc:`ProcessLookupError`"
msgstr ":exc:`ProcessLookupError`"

#: ../../c-api/exceptions.rst:962
msgid ":c:data:`PyExc_RecursionError`"
msgstr ":c:data:`PyExc_RecursionError`"

#: ../../c-api/exceptions.rst:962
msgid ":exc:`RecursionError`"
msgstr ":exc:`RecursionError`"

#: ../../c-api/exceptions.rst:964
msgid ":c:data:`PyExc_ReferenceError`"
msgstr ":c:data:`PyExc_ReferenceError`"

#: ../../c-api/exceptions.rst:964
msgid ":exc:`ReferenceError`"
msgstr ":exc:`ReferenceError`"

#: ../../c-api/exceptions.rst:966
msgid ":c:data:`PyExc_RuntimeError`"
msgstr ":c:data:`PyExc_RuntimeError`"

#: ../../c-api/exceptions.rst:966
msgid ":exc:`RuntimeError`"
msgstr ":exc:`RuntimeError`"

#: ../../c-api/exceptions.rst:968
msgid ":c:data:`PyExc_StopAsyncIteration`"
msgstr ":c:data:`PyExc_StopAsyncIteration`"

#: ../../c-api/exceptions.rst:968
msgid ":exc:`StopAsyncIteration`"
msgstr ":exc:`StopAsyncIteration`"

#: ../../c-api/exceptions.rst:970
msgid ":c:data:`PyExc_StopIteration`"
msgstr ":c:data:`PyExc_StopIteration`"

#: ../../c-api/exceptions.rst:970
msgid ":exc:`StopIteration`"
msgstr ":exc:`StopIteration`"

#: ../../c-api/exceptions.rst:972
msgid ":c:data:`PyExc_SyntaxError`"
msgstr ":c:data:`PyExc_SyntaxError`"

#: ../../c-api/exceptions.rst:972
msgid ":exc:`SyntaxError`"
msgstr ":exc:`SyntaxError`"

#: ../../c-api/exceptions.rst:974
msgid ":c:data:`PyExc_SystemError`"
msgstr ":c:data:`PyExc_SystemError`"

#: ../../c-api/exceptions.rst:974
msgid ":exc:`SystemError`"
msgstr ":exc:`SystemError`"

#: ../../c-api/exceptions.rst:976
msgid ":c:data:`PyExc_SystemExit`"
msgstr ":c:data:`PyExc_SystemExit`"

#: ../../c-api/exceptions.rst:976
msgid ":exc:`SystemExit`"
msgstr ":exc:`SystemExit`"

#: ../../c-api/exceptions.rst:978
msgid ":c:data:`PyExc_TabError`"
msgstr ":c:data:`PyExc_TabError`"

#: ../../c-api/exceptions.rst:978
msgid ":exc:`TabError`"
msgstr ":exc:`TabError`"

#: ../../c-api/exceptions.rst:980
msgid ":c:data:`PyExc_TimeoutError`"
msgstr ":c:data:`PyExc_TimeoutError`"

#: ../../c-api/exceptions.rst:980
msgid ":exc:`TimeoutError`"
msgstr ":exc:`TimeoutError`"

#: ../../c-api/exceptions.rst:982
msgid ":c:data:`PyExc_TypeError`"
msgstr ":c:data:`PyExc_TypeError`"

#: ../../c-api/exceptions.rst:982
msgid ":exc:`TypeError`"
msgstr ":exc:`TypeError`"

#: ../../c-api/exceptions.rst:984
msgid ":c:data:`PyExc_UnboundLocalError`"
msgstr ":c:data:`PyExc_UnboundLocalError`"

#: ../../c-api/exceptions.rst:984
msgid ":exc:`UnboundLocalError`"
msgstr ":exc:`UnboundLocalError`"

#: ../../c-api/exceptions.rst:986
msgid ":c:data:`PyExc_UnicodeDecodeError`"
msgstr ":c:data:`PyExc_UnicodeDecodeError`"

#: ../../c-api/exceptions.rst:986
msgid ":exc:`UnicodeDecodeError`"
msgstr ":exc:`UnicodeDecodeError`"

#: ../../c-api/exceptions.rst:988
msgid ":c:data:`PyExc_UnicodeEncodeError`"
msgstr ":c:data:`PyExc_UnicodeEncodeError`"

#: ../../c-api/exceptions.rst:988
msgid ":exc:`UnicodeEncodeError`"
msgstr ":exc:`UnicodeEncodeError`"

#: ../../c-api/exceptions.rst:990
msgid ":c:data:`PyExc_UnicodeError`"
msgstr ":c:data:`PyExc_UnicodeError`"

#: ../../c-api/exceptions.rst:990
msgid ":exc:`UnicodeError`"
msgstr ":exc:`UnicodeError`"

#: ../../c-api/exceptions.rst:992
msgid ":c:data:`PyExc_UnicodeTranslateError`"
msgstr ":c:data:`PyExc_UnicodeTranslateError`"

#: ../../c-api/exceptions.rst:992
msgid ":exc:`UnicodeTranslateError`"
msgstr ":exc:`UnicodeTranslateError`"

#: ../../c-api/exceptions.rst:994
msgid ":c:data:`PyExc_ValueError`"
msgstr ":c:data:`PyExc_ValueError`"

#: ../../c-api/exceptions.rst:994
msgid ":exc:`ValueError`"
msgstr ":exc:`ValueError`"

#: ../../c-api/exceptions.rst:996
msgid ":c:data:`PyExc_ZeroDivisionError`"
msgstr ":c:data:`PyExc_ZeroDivisionError`"

#: ../../c-api/exceptions.rst:996
msgid ":exc:`ZeroDivisionError`"
msgstr ":exc:`ZeroDivisionError`"

#: ../../c-api/exceptions.rst:999
msgid ""
":c:data:`PyExc_BlockingIOError`, :c:data:`PyExc_BrokenPipeError`, :c:data:"
"`PyExc_ChildProcessError`, :c:data:`PyExc_ConnectionError`, :c:data:"
"`PyExc_ConnectionAbortedError`, :c:data:`PyExc_ConnectionRefusedError`, :c:"
"data:`PyExc_ConnectionResetError`, :c:data:`PyExc_FileExistsError`, :c:data:"
"`PyExc_FileNotFoundError`, :c:data:`PyExc_InterruptedError`, :c:data:"
"`PyExc_IsADirectoryError`, :c:data:`PyExc_NotADirectoryError`, :c:data:"
"`PyExc_PermissionError`, :c:data:`PyExc_ProcessLookupError` and :c:data:"
"`PyExc_TimeoutError` were introduced following :pep:`3151`."
msgstr ""
":c:data:`PyExc_BlockingIOError` 、 :c:data:`PyExc_BrokenPipeError` 、 :c:"
"data:`PyExc_ChildProcessError` 、 :c:data:`PyExc_ConnectionError` 、 :c:data:"
"`PyExc_ConnectionAbortedError` 、 :c:data:`PyExc_ConnectionRefusedError` 、 :"
"c:data:`PyExc_ConnectionResetError` 、 :c:data:`PyExc_FileExistsError` 、 :c:"
"data:`PyExc_FileNotFoundError` 、 :c:data:`PyExc_InterruptedError` 、 :c:"
"data:`PyExc_IsADirectoryError` 、 :c:data:`PyExc_NotADirectoryError` 、 :c:"
"data:`PyExc_PermissionError` 、 :c:data:`PyExc_ProcessLookupError`  、 :c:"
"data:`PyExc_TimeoutError` は :pep:`3151` により導入されました。"

#: ../../c-api/exceptions.rst:1009
msgid ":c:data:`PyExc_StopAsyncIteration` and :c:data:`PyExc_RecursionError`."
msgstr ""
":c:data:`PyExc_StopAsyncIteration` および :c:data:`PyExc_RecursionError` 。"

#: ../../c-api/exceptions.rst:1012
msgid ":c:data:`PyExc_ModuleNotFoundError`."
msgstr ":c:data:`PyExc_ModuleNotFoundError`."

#: ../../c-api/exceptions.rst:1015
msgid "These are compatibility aliases to :c:data:`PyExc_OSError`:"
msgstr "これらは互換性のある :c:data:`PyExc_OSError` のエイリアスです:"

#: ../../c-api/exceptions.rst:1025
msgid ":c:data:`PyExc_EnvironmentError`"
msgstr ":c:data:`PyExc_EnvironmentError`"

#: ../../c-api/exceptions.rst:1027
msgid ":c:data:`PyExc_IOError`"
msgstr ":c:data:`PyExc_IOError`"

#: ../../c-api/exceptions.rst:1029
msgid ":c:data:`PyExc_WindowsError`"
msgstr ":c:data:`PyExc_WindowsError`"

#: ../../c-api/exceptions.rst:1029
msgid "[2]_"
msgstr "[2]_"

#: ../../c-api/exceptions.rst:1032
msgid "These aliases used to be separate exception types."
msgstr "これらのエイリアスは例外の種類を分けるために使われます。"

#: ../../c-api/exceptions.rst:1035 ../../c-api/exceptions.rst:1096
msgid "Notes:"
msgstr "注釈:"

#: ../../c-api/exceptions.rst:1038
msgid "This is a base class for other standard exceptions."
msgstr "これは別の標準例外のためのベースクラスです。"

#: ../../c-api/exceptions.rst:1041
msgid ""
"Only defined on Windows; protect code that uses this by testing that the "
"preprocessor macro ``MS_WINDOWS`` is defined."
msgstr ""
"Windowsでのみ定義されています。プリプロセッサマクロ ``MS_WINDOWS`` が定義され"
"ているかテストすることで、これを使うコードを保護してください。"

#: ../../c-api/exceptions.rst:1047
msgid "Standard Warning Categories"
msgstr "標準警告カテゴリ"

#: ../../c-api/exceptions.rst:1049
msgid ""
"All standard Python warning categories are available as global variables "
"whose names are ``PyExc_`` followed by the Python exception name. These have "
"the type :c:expr:`PyObject*`; they are all class objects. For completeness, "
"here are all the variables:"
msgstr ""
"``PyExc_`` の後ろにPythonの例外名が続く名前をもつグローバル変数として、すべて"
"の標準Python警告カテゴリが利用可能です。これらは型 :c:expr:`PyObject*` を持"
"ち、すべてクラスオブジェクトです。完璧を期するために、すべての変数を以下に列"
"挙します:"

#: ../../c-api/exceptions.rst:1070
msgid ":c:data:`PyExc_Warning`"
msgstr ":c:data:`PyExc_Warning`"

#: ../../c-api/exceptions.rst:1070
msgid ":exc:`Warning`"
msgstr ":exc:`Warning`"

#: ../../c-api/exceptions.rst:1070
msgid "[3]_"
msgstr "[3]_"

#: ../../c-api/exceptions.rst:1072
msgid ":c:data:`PyExc_BytesWarning`"
msgstr ":c:data:`PyExc_BytesWarning`"

#: ../../c-api/exceptions.rst:1072
msgid ":exc:`BytesWarning`"
msgstr ":exc:`BytesWarning`"

#: ../../c-api/exceptions.rst:1074
msgid ":c:data:`PyExc_DeprecationWarning`"
msgstr ":c:data:`PyExc_DeprecationWarning`"

#: ../../c-api/exceptions.rst:1074
msgid ":exc:`DeprecationWarning`"
msgstr ":exc:`DeprecationWarning`"

#: ../../c-api/exceptions.rst:1076
msgid ":c:data:`PyExc_FutureWarning`"
msgstr ":c:data:`PyExc_FutureWarning`"

#: ../../c-api/exceptions.rst:1076
msgid ":exc:`FutureWarning`"
msgstr ":exc:`FutureWarning`"

#: ../../c-api/exceptions.rst:1078
msgid ":c:data:`PyExc_ImportWarning`"
msgstr ":c:data:`PyExc_ImportWarning`"

#: ../../c-api/exceptions.rst:1078
msgid ":exc:`ImportWarning`"
msgstr ":exc:`ImportWarning`"

#: ../../c-api/exceptions.rst:1080
msgid ":c:data:`PyExc_PendingDeprecationWarning`"
msgstr ":c:data:`PyExc_PendingDeprecationWarning`"

#: ../../c-api/exceptions.rst:1080
msgid ":exc:`PendingDeprecationWarning`"
msgstr ":exc:`PendingDeprecationWarning`"

#: ../../c-api/exceptions.rst:1082
msgid ":c:data:`PyExc_ResourceWarning`"
msgstr ":c:data:`PyExc_ResourceWarning`"

#: ../../c-api/exceptions.rst:1082
msgid ":exc:`ResourceWarning`"
msgstr ":exc:`ResourceWarning`"

#: ../../c-api/exceptions.rst:1084
msgid ":c:data:`PyExc_RuntimeWarning`"
msgstr ":c:data:`PyExc_RuntimeWarning`"

#: ../../c-api/exceptions.rst:1084
msgid ":exc:`RuntimeWarning`"
msgstr ":exc:`RuntimeWarning`"

#: ../../c-api/exceptions.rst:1086
msgid ":c:data:`PyExc_SyntaxWarning`"
msgstr ":c:data:`PyExc_SyntaxWarning`"

#: ../../c-api/exceptions.rst:1086
msgid ":exc:`SyntaxWarning`"
msgstr ":exc:`SyntaxWarning`"

#: ../../c-api/exceptions.rst:1088
msgid ":c:data:`PyExc_UnicodeWarning`"
msgstr ":c:data:`PyExc_UnicodeWarning`"

#: ../../c-api/exceptions.rst:1088
msgid ":exc:`UnicodeWarning`"
msgstr ":exc:`UnicodeWarning`"

#: ../../c-api/exceptions.rst:1090
msgid ":c:data:`PyExc_UserWarning`"
msgstr ":c:data:`PyExc_UserWarning`"

#: ../../c-api/exceptions.rst:1090
msgid ":exc:`UserWarning`"
msgstr ":exc:`UserWarning`"

#: ../../c-api/exceptions.rst:1093
msgid ":c:data:`PyExc_ResourceWarning`."
msgstr ":c:data:`PyExc_ResourceWarning`."

#: ../../c-api/exceptions.rst:1099
msgid "This is a base class for other standard warning categories."
msgstr "これは別の標準警告カテゴリのためのベースクラスです。"