warnings.po

# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2001-2022, Python Software Foundation
# This file is distributed under the same license as the Python package.
#
# Translators:
msgid ""
msgstr ""
"Project-Id-Version: Python 3.13\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2024-11-03 00:14+0000\n"
"PO-Revision-Date: 2018-05-23 16:15+0000\n"
"Last-Translator: Adrian Liaw <adrianliaw2000@gmail.com>\n"
"Language-Team: Chinese - TAIWAN (https://github.com/python/python-docs-zh-"
"tw)\n"
"Language: zh_TW\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"

#: ../../library/warnings.rst:2
msgid ":mod:`!warnings` --- Warning control"
msgstr ":mod:`!warnings` --- 警告控制"

#: ../../library/warnings.rst:7
msgid "**Source code:** :source:`Lib/warnings.py`"
msgstr "**原始碼：**\\ :source:`Lib/warnings.py`"

#: ../../library/warnings.rst:13
msgid ""
"Warning messages are typically issued in situations where it is useful to "
"alert the user of some condition in a program, where that condition "
"(normally) doesn't warrant raising an exception and terminating the "
"program.  For example, one might want to issue a warning when a program uses "
"an obsolete module."
msgstr ""

#: ../../library/warnings.rst:18
msgid ""
"Python programmers issue warnings by calling the :func:`warn` function "
"defined in this module.  (C programmers use :c:func:`PyErr_WarnEx`; see :ref:"
"`exceptionhandling` for details)."
msgstr ""

#: ../../library/warnings.rst:22
msgid ""
"Warning messages are normally written to :data:`sys.stderr`, but their "
"disposition can be changed flexibly, from ignoring all warnings to turning "
"them into exceptions.  The disposition of warnings can vary based on the :"
"ref:`warning category <warning-categories>`, the text of the warning "
"message, and the source location where it is issued.  Repetitions of a "
"particular warning for the same source location are typically suppressed."
msgstr ""

#: ../../library/warnings.rst:29
msgid ""
"There are two stages in warning control: first, each time a warning is "
"issued, a determination is made whether a message should be issued or not; "
"next, if a message is to be issued, it is formatted and printed using a user-"
"settable hook."
msgstr ""

#: ../../library/warnings.rst:33
msgid ""
"The determination whether to issue a warning message is controlled by the :"
"ref:`warning filter <warning-filter>`, which is a sequence of matching rules "
"and actions. Rules can be added to the filter by calling :func:"
"`filterwarnings` and reset to its default state by calling :func:"
"`resetwarnings`."
msgstr ""

#: ../../library/warnings.rst:38
msgid ""
"The printing of warning messages is done by calling :func:`showwarning`, "
"which may be overridden; the default implementation of this function formats "
"the message by calling :func:`formatwarning`, which is also available for "
"use by custom implementations."
msgstr ""

#: ../../library/warnings.rst:44
msgid ""
":func:`logging.captureWarnings` allows you to handle all warnings with the "
"standard logging infrastructure."
msgstr ""

#: ../../library/warnings.rst:51
msgid "Warning Categories"
msgstr ""

#: ../../library/warnings.rst:53
msgid ""
"There are a number of built-in exceptions that represent warning categories. "
"This categorization is useful to be able to filter out groups of warnings."
msgstr ""

#: ../../library/warnings.rst:56
msgid ""
"While these are technically :ref:`built-in exceptions <warning-categories-as-"
"exceptions>`, they are documented here, because conceptually they belong to "
"the warnings mechanism."
msgstr ""

#: ../../library/warnings.rst:60
msgid ""
"User code can define additional warning categories by subclassing one of the "
"standard warning categories.  A warning category must always be a subclass "
"of the :exc:`Warning` class."
msgstr ""

#: ../../library/warnings.rst:64
msgid "The following warnings category classes are currently defined:"
msgstr ""

#: ../../library/warnings.rst:69
msgid "Class"
msgstr ""

#: ../../library/warnings.rst:69
msgid "Description"
msgstr "描述"

#: ../../library/warnings.rst:71
msgid ":exc:`Warning`"
msgstr ":exc:`Warning`"

#: ../../library/warnings.rst:71
msgid ""
"This is the base class of all warning category classes.  It is a subclass "
"of :exc:`Exception`."
msgstr ""

#: ../../library/warnings.rst:75
msgid ":exc:`UserWarning`"
msgstr ":exc:`UserWarning`"

#: ../../library/warnings.rst:75
msgid "The default category for :func:`warn`."
msgstr ""

#: ../../library/warnings.rst:77
msgid ":exc:`DeprecationWarning`"
msgstr ":exc:`DeprecationWarning`"

#: ../../library/warnings.rst:77
msgid ""
"Base category for warnings about deprecated features when those warnings are "
"intended for other Python developers (ignored by default, unless triggered "
"by code in ``__main__``)."
msgstr ""

#: ../../library/warnings.rst:82
msgid ":exc:`SyntaxWarning`"
msgstr ":exc:`SyntaxWarning`"

#: ../../library/warnings.rst:82
msgid "Base category for warnings about dubious syntactic features."
msgstr ""

#: ../../library/warnings.rst:85
msgid ":exc:`RuntimeWarning`"
msgstr ":exc:`RuntimeWarning`"

#: ../../library/warnings.rst:85
msgid "Base category for warnings about dubious runtime features."
msgstr ""

#: ../../library/warnings.rst:88
msgid ":exc:`FutureWarning`"
msgstr ":exc:`FutureWarning`"

#: ../../library/warnings.rst:88
msgid ""
"Base category for warnings about deprecated features when those warnings are "
"intended for end users of applications that are written in Python."
msgstr ""

#: ../../library/warnings.rst:93
msgid ":exc:`PendingDeprecationWarning`"
msgstr ":exc:`PendingDeprecationWarning`"

#: ../../library/warnings.rst:93
msgid ""
"Base category for warnings about features that will be deprecated in the "
"future (ignored by default)."
msgstr ""

#: ../../library/warnings.rst:97
msgid ":exc:`ImportWarning`"
msgstr ":exc:`ImportWarning`"

#: ../../library/warnings.rst:97
msgid ""
"Base category for warnings triggered during the process of importing a "
"module (ignored by default)."
msgstr ""

#: ../../library/warnings.rst:101
msgid ":exc:`UnicodeWarning`"
msgstr ":exc:`UnicodeWarning`"

#: ../../library/warnings.rst:101
msgid "Base category for warnings related to Unicode."
msgstr ""

#: ../../library/warnings.rst:104
msgid ":exc:`BytesWarning`"
msgstr ":exc:`BytesWarning`"

#: ../../library/warnings.rst:104
msgid ""
"Base category for warnings related to :class:`bytes` and :class:`bytearray`."
msgstr ""

#: ../../library/warnings.rst:107
msgid ":exc:`ResourceWarning`"
msgstr ":exc:`ResourceWarning`"

#: ../../library/warnings.rst:107
msgid ""
"Base category for warnings related to resource usage (ignored by default)."
msgstr ""

#: ../../library/warnings.rst:111
msgid ""
"Previously :exc:`DeprecationWarning` and :exc:`FutureWarning` were "
"distinguished based on whether a feature was being removed entirely or "
"changing its behaviour. They are now distinguished based on their intended "
"audience and the way they're handled by the default warnings filters."
msgstr ""

#: ../../library/warnings.rst:122
msgid "The Warnings Filter"
msgstr ""

#: ../../library/warnings.rst:124
msgid ""
"The warnings filter controls whether warnings are ignored, displayed, or "
"turned into errors (raising an exception)."
msgstr ""

#: ../../library/warnings.rst:127
msgid ""
"Conceptually, the warnings filter maintains an ordered list of filter "
"specifications; any specific warning is matched against each filter "
"specification in the list in turn until a match is found; the filter "
"determines the disposition of the match.  Each entry is a tuple of the form "
"(*action*, *message*, *category*, *module*, *lineno*), where:"
msgstr ""

#: ../../library/warnings.rst:133
msgid "*action* is one of the following strings:"
msgstr ""

#: ../../library/warnings.rst:136
msgid "Value"
msgstr ""

#: ../../library/warnings.rst:136
msgid "Disposition"
msgstr ""

#: ../../library/warnings.rst:138
msgid "``\"default\"``"
msgstr "``\"default\"``"

#: ../../library/warnings.rst:138
msgid ""
"print the first occurrence of matching warnings for each location (module + "
"line number) where the warning is issued"
msgstr ""

#: ../../library/warnings.rst:142
msgid "``\"error\"``"
msgstr "``\"error\"``"

#: ../../library/warnings.rst:142
msgid "turn matching warnings into exceptions"
msgstr ""

#: ../../library/warnings.rst:144
msgid "``\"ignore\"``"
msgstr "``\"ignore\"``"

#: ../../library/warnings.rst:144
msgid "never print matching warnings"
msgstr ""

#: ../../library/warnings.rst:146
msgid "``\"always\"``"
msgstr "``\"always\"``"

#: ../../library/warnings.rst:146
msgid "always print matching warnings"
msgstr ""

#: ../../library/warnings.rst:148
msgid "``\"module\"``"
msgstr "``\"module\"``"

#: ../../library/warnings.rst:148
msgid ""
"print the first occurrence of matching warnings for each module where the "
"warning is issued (regardless of line number)"
msgstr ""

#: ../../library/warnings.rst:152
msgid "``\"once\"``"
msgstr "``\"once\"``"

#: ../../library/warnings.rst:152
msgid ""
"print only the first occurrence of matching warnings, regardless of location"
msgstr ""

#: ../../library/warnings.rst:156
msgid ""
"*message* is a string containing a regular expression that the start of the "
"warning message must match, case-insensitively.  In :option:`-W` and :envvar:"
"`PYTHONWARNINGS`, *message* is a literal string that the start of the "
"warning message must contain (case-insensitively), ignoring any whitespace "
"at the start or end of *message*."
msgstr ""

#: ../../library/warnings.rst:162
msgid ""
"*category* is a class (a subclass of :exc:`Warning`) of which the warning "
"category must be a subclass in order to match."
msgstr ""

#: ../../library/warnings.rst:165
msgid ""
"*module* is a string containing a regular expression that the start of the "
"fully qualified module name must match, case-sensitively.  In :option:`-W` "
"and :envvar:`PYTHONWARNINGS`, *module* is a literal string that the fully "
"qualified module name must be equal to (case-sensitively), ignoring any "
"whitespace at the start or end of *module*."
msgstr ""

#: ../../library/warnings.rst:171
msgid ""
"*lineno* is an integer that the line number where the warning occurred must "
"match, or ``0`` to match all line numbers."
msgstr ""

#: ../../library/warnings.rst:174
msgid ""
"Since the :exc:`Warning` class is derived from the built-in :exc:`Exception` "
"class, to turn a warning into an error we simply raise ``category(message)``."
msgstr ""

#: ../../library/warnings.rst:177
msgid ""
"If a warning is reported and doesn't match any registered filter then the "
"\"default\" action is applied (hence its name)."
msgstr ""

#: ../../library/warnings.rst:185
msgid "Repeated Warning Suppression Criteria"
msgstr ""

#: ../../library/warnings.rst:187
msgid ""
"The filters that suppress repeated warnings apply the following criteria to "
"determine if a warning is considered a repeat:"
msgstr ""

#: ../../library/warnings.rst:189
msgid ""
"``\"default\"``: A warning is considered a repeat only if the (*message*, "
"*category*, *module*, *lineno*) are all the same."
msgstr ""

#: ../../library/warnings.rst:190
msgid ""
"``\"module\"``: A warning is considered a repeat if the (*message*, "
"*category*, *module*) are the same, ignoring the line number."
msgstr ""

#: ../../library/warnings.rst:191
msgid ""
"``\"once\"``: A warning is considered a repeat if the (*message*, "
"*category*) are the same, ignoring the module and line number."
msgstr ""

#: ../../library/warnings.rst:197
msgid "Describing Warning Filters"
msgstr ""

#: ../../library/warnings.rst:199
msgid ""
"The warnings filter is initialized by :option:`-W` options passed to the "
"Python interpreter command line and the :envvar:`PYTHONWARNINGS` environment "
"variable. The interpreter saves the arguments for all supplied entries "
"without interpretation in :data:`sys.warnoptions`; the :mod:`warnings` "
"module parses these when it is first imported (invalid options are ignored, "
"after printing a message to :data:`sys.stderr`)."
msgstr ""

#: ../../library/warnings.rst:206
msgid ""
"Individual warnings filters are specified as a sequence of fields separated "
"by colons::"
msgstr ""

#: ../../library/warnings.rst:209
msgid "action:message:category:module:line"
msgstr "action:message:category:module:line"

#: ../../library/warnings.rst:211
msgid ""
"The meaning of each of these fields is as described in :ref:`warning-"
"filter`. When listing multiple filters on a single line (as for :envvar:"
"`PYTHONWARNINGS`), the individual filters are separated by commas and the "
"filters listed later take precedence over those listed before them (as "
"they're applied left-to-right, and the most recently applied filters take "
"precedence over earlier ones)."
msgstr ""

#: ../../library/warnings.rst:218
msgid ""
"Commonly used warning filters apply to either all warnings, warnings in a "
"particular category, or warnings raised by particular modules or packages. "
"Some examples::"
msgstr ""

#: ../../library/warnings.rst:222
msgid ""
"default                      # Show all warnings (even those ignored by "
"default)\n"
"ignore                       # Ignore all warnings\n"
"error                        # Convert all warnings to errors\n"
"error::ResourceWarning       # Treat ResourceWarning messages as errors\n"
"default::DeprecationWarning  # Show DeprecationWarning messages\n"
"ignore,default:::mymodule    # Only report warnings triggered by "
"\"mymodule\"\n"
"error:::mymodule             # Convert warnings to errors in \"mymodule\""
msgstr ""

#: ../../library/warnings.rst:234
msgid "Default Warning Filter"
msgstr ""

#: ../../library/warnings.rst:236
msgid ""
"By default, Python installs several warning filters, which can be overridden "
"by the :option:`-W` command-line option, the :envvar:`PYTHONWARNINGS` "
"environment variable and calls to :func:`filterwarnings`."
msgstr ""

#: ../../library/warnings.rst:240
msgid ""
"In regular release builds, the default warning filter has the following "
"entries (in order of precedence)::"
msgstr ""

#: ../../library/warnings.rst:243
msgid ""
"default::DeprecationWarning:__main__\n"
"ignore::DeprecationWarning\n"
"ignore::PendingDeprecationWarning\n"
"ignore::ImportWarning\n"
"ignore::ResourceWarning"
msgstr ""
"default::DeprecationWarning:__main__\n"
"ignore::DeprecationWarning\n"
"ignore::PendingDeprecationWarning\n"
"ignore::ImportWarning\n"
"ignore::ResourceWarning"

#: ../../library/warnings.rst:249
msgid ""
"In a :ref:`debug build <debug-build>`, the list of default warning filters "
"is empty."
msgstr ""

#: ../../library/warnings.rst:251
msgid ""
":exc:`DeprecationWarning` is now ignored by default in addition to :exc:"
"`PendingDeprecationWarning`."
msgstr ""

#: ../../library/warnings.rst:255
msgid ""
":exc:`DeprecationWarning` is once again shown by default when triggered "
"directly by code in ``__main__``."
msgstr ""

#: ../../library/warnings.rst:259
msgid ""
":exc:`BytesWarning` no longer appears in the default filter list and is "
"instead configured via :data:`sys.warnoptions` when :option:`-b` is "
"specified twice."
msgstr ""

#: ../../library/warnings.rst:268
msgid "Overriding the default filter"
msgstr ""

#: ../../library/warnings.rst:270
msgid ""
"Developers of applications written in Python may wish to hide *all* Python "
"level warnings from their users by default, and only display them when "
"running tests or otherwise working on the application. The :data:`sys."
"warnoptions` attribute used to pass filter configurations to the interpreter "
"can be used as a marker to indicate whether or not warnings should be "
"disabled::"
msgstr ""

#: ../../library/warnings.rst:276
msgid ""
"import sys\n"
"\n"
"if not sys.warnoptions:\n"
"    import warnings\n"
"    warnings.simplefilter(\"ignore\")"
msgstr ""
"import sys\n"
"\n"
"if not sys.warnoptions:\n"
"    import warnings\n"
"    warnings.simplefilter(\"ignore\")"

#: ../../library/warnings.rst:282
msgid ""
"Developers of test runners for Python code are advised to instead ensure "
"that *all* warnings are displayed by default for the code under test, using "
"code like::"
msgstr ""

#: ../../library/warnings.rst:286
msgid ""
"import sys\n"
"\n"
"if not sys.warnoptions:\n"
"    import os, warnings\n"
"    warnings.simplefilter(\"default\") # Change the filter in this process\n"
"    os.environ[\"PYTHONWARNINGS\"] = \"default\" # Also affect subprocesses"
msgstr ""

#: ../../library/warnings.rst:293
msgid ""
"Finally, developers of interactive shells that run user code in a namespace "
"other than ``__main__`` are advised to ensure that :exc:`DeprecationWarning` "
"messages are made visible by default, using code like the following (where "
"``user_ns`` is the module used to execute code entered interactively)::"
msgstr ""

#: ../../library/warnings.rst:298
msgid ""
"import warnings\n"
"warnings.filterwarnings(\"default\", category=DeprecationWarning,\n"
"                                   module=user_ns.get(\"__name__\"))"
msgstr ""
"import warnings\n"
"warnings.filterwarnings(\"default\", category=DeprecationWarning,\n"
"                                   module=user_ns.get(\"__name__\"))"

#: ../../library/warnings.rst:306
msgid "Temporarily Suppressing Warnings"
msgstr ""

#: ../../library/warnings.rst:308
msgid ""
"If you are using code that you know will raise a warning, such as a "
"deprecated function, but do not want to see the warning (even when warnings "
"have been explicitly configured via the command line), then it is possible "
"to suppress the warning using the :class:`catch_warnings` context manager::"
msgstr ""

#: ../../library/warnings.rst:313
msgid ""
"import warnings\n"
"\n"
"def fxn():\n"
"    warnings.warn(\"deprecated\", DeprecationWarning)\n"
"\n"
"with warnings.catch_warnings():\n"
"    warnings.simplefilter(\"ignore\")\n"
"    fxn()"
msgstr ""
"import warnings\n"
"\n"
"def fxn():\n"
"    warnings.warn(\"deprecated\", DeprecationWarning)\n"
"\n"
"with warnings.catch_warnings():\n"
"    warnings.simplefilter(\"ignore\")\n"
"    fxn()"

#: ../../library/warnings.rst:322
msgid ""
"While within the context manager all warnings will simply be ignored. This "
"allows you to use known-deprecated code without having to see the warning "
"while not suppressing the warning for other code that might not be aware of "
"its use of deprecated code.  Note: this can only be guaranteed in a single-"
"threaded application. If two or more threads use the :class:`catch_warnings` "
"context manager at the same time, the behavior is undefined."
msgstr ""

#: ../../library/warnings.rst:334
msgid "Testing Warnings"
msgstr ""

#: ../../library/warnings.rst:336
msgid ""
"To test warnings raised by code, use the :class:`catch_warnings` context "
"manager. With it you can temporarily mutate the warnings filter to "
"facilitate your testing. For instance, do the following to capture all "
"raised warnings to check::"
msgstr ""

#: ../../library/warnings.rst:341
msgid ""
"import warnings\n"
"\n"
"def fxn():\n"
"    warnings.warn(\"deprecated\", DeprecationWarning)\n"
"\n"
"with warnings.catch_warnings(record=True) as w:\n"
"    # Cause all warnings to always be triggered.\n"
"    warnings.simplefilter(\"always\")\n"
"    # Trigger a warning.\n"
"    fxn()\n"
"    # Verify some things\n"
"    assert len(w) == 1\n"
"    assert issubclass(w[-1].category, DeprecationWarning)\n"
"    assert \"deprecated\" in str(w[-1].message)"
msgstr ""

#: ../../library/warnings.rst:356
msgid ""
"One can also cause all warnings to be exceptions by using ``error`` instead "
"of ``always``. One thing to be aware of is that if a warning has already "
"been raised because of a ``once``/``default`` rule, then no matter what "
"filters are set the warning will not be seen again unless the warnings "
"registry related to the warning has been cleared."
msgstr ""

#: ../../library/warnings.rst:362
msgid ""
"Once the context manager exits, the warnings filter is restored to its state "
"when the context was entered. This prevents tests from changing the warnings "
"filter in unexpected ways between tests and leading to indeterminate test "
"results. The :func:`showwarning` function in the module is also restored to "
"its original value.  Note: this can only be guaranteed in a single-threaded "
"application. If two or more threads use the :class:`catch_warnings` context "
"manager at the same time, the behavior is undefined."
msgstr ""

#: ../../library/warnings.rst:370
msgid ""
"When testing multiple operations that raise the same kind of warning, it is "
"important to test them in a manner that confirms each operation is raising a "
"new warning (e.g. set warnings to be raised as exceptions and check the "
"operations raise exceptions, check that the length of the warning list "
"continues to increase after each operation, or else delete the previous "
"entries from the warnings list before each new operation)."
msgstr ""

#: ../../library/warnings.rst:381
msgid "Updating Code For New Versions of Dependencies"
msgstr ""

#: ../../library/warnings.rst:383
msgid ""
"Warning categories that are primarily of interest to Python developers "
"(rather than end users of applications written in Python) are ignored by "
"default."
msgstr ""

#: ../../library/warnings.rst:386
msgid ""
"Notably, this \"ignored by default\" list includes :exc:`DeprecationWarning` "
"(for every module except ``__main__``), which means developers should make "
"sure to test their code with typically ignored warnings made visible in "
"order to receive timely notifications of future breaking API changes "
"(whether in the standard library or third party packages)."
msgstr ""

#: ../../library/warnings.rst:392
msgid ""
"In the ideal case, the code will have a suitable test suite, and the test "
"runner will take care of implicitly enabling all warnings when running tests "
"(the test runner provided by the :mod:`unittest` module does this)."
msgstr ""

#: ../../library/warnings.rst:396
msgid ""
"In less ideal cases, applications can be checked for use of deprecated "
"interfaces by passing :option:`-Wd <-W>` to the Python interpreter (this is "
"shorthand for :option:`!-W default`) or setting ``PYTHONWARNINGS=default`` "
"in the environment. This enables default handling for all warnings, "
"including those that are ignored by default. To change what action is taken "
"for encountered warnings you can change what argument is passed to :option:`-"
"W` (e.g. :option:`!-W error`). See the :option:`-W` flag for more details on "
"what is possible."
msgstr ""

#: ../../library/warnings.rst:409
msgid "Available Functions"
msgstr ""

#: ../../library/warnings.rst:414
msgid ""
"Issue a warning, or maybe ignore it or raise an exception.  The *category* "
"argument, if given, must be a :ref:`warning category class <warning-"
"categories>`; it defaults to :exc:`UserWarning`.  Alternatively, *message* "
"can be a :exc:`Warning` instance, in which case *category* will be ignored "
"and ``message.__class__`` will be used. In this case, the message text will "
"be ``str(message)``. This function raises an exception if the particular "
"warning issued is changed into an error by the :ref:`warnings filter "
"<warning-filter>`.  The *stacklevel* argument can be used by wrapper "
"functions written in Python, like this::"
msgstr ""

#: ../../library/warnings.rst:423
msgid ""
"def deprecated_api(message):\n"
"    warnings.warn(message, DeprecationWarning, stacklevel=2)"
msgstr ""
"def deprecated_api(message):\n"
"    warnings.warn(message, DeprecationWarning, stacklevel=2)"

#: ../../library/warnings.rst:426
msgid ""
"This makes the warning refer to ``deprecated_api``'s caller, rather than to "
"the source of ``deprecated_api`` itself (since the latter would defeat the "
"purpose of the warning message)."
msgstr ""

#: ../../library/warnings.rst:430
msgid ""
"The *skip_file_prefixes* keyword argument can be used to indicate which "
"stack frames are ignored when counting stack levels. This can be useful when "
"you want the warning to always appear at call sites outside of a package "
"when a constant *stacklevel* does not fit all call paths or is otherwise "
"challenging to maintain. If supplied, it must be a tuple of strings. When "
"prefixes are supplied, stacklevel is implicitly overridden to be ``max(2, "
"stacklevel)``. To cause a warning to be attributed to the caller from "
"outside of the current package you might write::"
msgstr ""

#: ../../library/warnings.rst:439
msgid ""
"# example/lower.py\n"
"_warn_skips = (os.path.dirname(__file__),)\n"
"\n"
"def one_way(r_luxury_yacht=None, t_wobbler_mangrove=None):\n"
"    if r_luxury_yacht:\n"
"        warnings.warn(\"Please migrate to t_wobbler_mangrove=.\",\n"
"                      skip_file_prefixes=_warn_skips)\n"
"\n"
"# example/higher.py\n"
"from . import lower\n"
"\n"
"def another_way(**kw):\n"
"    lower.one_way(**kw)"
msgstr ""

#: ../../library/warnings.rst:453
msgid ""
"This makes the warning refer to both the ``example.lower.one_way()`` and "
"``package.higher.another_way()`` call sites only from calling code living "
"outside of ``example`` package."
msgstr ""

#: ../../library/warnings.rst:457 ../../library/warnings.rst:483
msgid ""
"*source*, if supplied, is the destroyed object which emitted a :exc:"
"`ResourceWarning`."
msgstr ""

#: ../../library/warnings.rst:460
msgid "Added *source* parameter."
msgstr "新增 *source* 參數。"

#: ../../library/warnings.rst:463
msgid "Added *skip_file_prefixes*."
msgstr "新增 *skip_file_prefixes*。"

#: ../../library/warnings.rst:469
msgid ""
"This is a low-level interface to the functionality of :func:`warn`, passing "
"in explicitly the message, category, filename and line number, and "
"optionally the module name and the registry (which should be the "
"``__warningregistry__`` dictionary of the module).  The module name defaults "
"to the filename with ``.py`` stripped; if no registry is passed, the warning "
"is never suppressed. *message* must be a string and *category* a subclass "
"of :exc:`Warning` or *message* may be a :exc:`Warning` instance, in which "
"case *category* will be ignored."
msgstr ""

#: ../../library/warnings.rst:478
msgid ""
"*module_globals*, if supplied, should be the global namespace in use by the "
"code for which the warning is issued.  (This argument is used to support "
"displaying source for modules found in zipfiles or other non-filesystem "
"import sources)."
msgstr ""

#: ../../library/warnings.rst:486
msgid "Add the *source* parameter."
msgstr ""

#: ../../library/warnings.rst:492
msgid ""
"Write a warning to a file.  The default implementation calls "
"``formatwarning(message, category, filename, lineno, line)`` and writes the "
"resulting string to *file*, which defaults to :data:`sys.stderr`.  You may "
"replace this function with any callable by assigning to ``warnings."
"showwarning``. *line* is a line of source code to be included in the warning "
"message; if *line* is not supplied, :func:`showwarning` will try to read the "
"line specified by *filename* and *lineno*."
msgstr ""

#: ../../library/warnings.rst:503
msgid ""
"Format a warning the standard way.  This returns a string which may contain "
"embedded newlines and ends in a newline.  *line* is a line of source code to "
"be included in the warning message; if *line* is not supplied, :func:"
"`formatwarning` will try to read the line specified by *filename* and "
"*lineno*."
msgstr ""

#: ../../library/warnings.rst:512
msgid ""
"Insert an entry into the list of :ref:`warnings filter specifications "
"<warning-filter>`.  The entry is inserted at the front by default; if "
"*append* is true, it is inserted at the end.  This checks the types of the "
"arguments, compiles the *message* and *module* regular expressions, and "
"inserts them as a tuple in the list of warnings filters.  Entries closer to "
"the front of the list override entries later in the list, if both match a "
"particular warning.  Omitted arguments default to a value that matches "
"everything."
msgstr ""

#: ../../library/warnings.rst:524
msgid ""
"Insert a simple entry into the list of :ref:`warnings filter specifications "
"<warning-filter>`.  The meaning of the function parameters is as for :func:"
"`filterwarnings`, but regular expressions are not needed as the filter "
"inserted always matches any message in any module as long as the category "
"and line number match."
msgstr ""

#: ../../library/warnings.rst:533
msgid ""
"Reset the warnings filter.  This discards the effect of all previous calls "
"to :func:`filterwarnings`, including that of the :option:`-W` command line "
"options and calls to :func:`simplefilter`."
msgstr ""

#: ../../library/warnings.rst:540
msgid "Decorator to indicate that a class, function or overload is deprecated."
msgstr ""

#: ../../library/warnings.rst:542
msgid ""
"When this decorator is applied to an object, deprecation warnings may be "
"emitted at runtime when the object is used. :term:`static type checkers "
"<static type checker>` will also generate a diagnostic on usage of the "
"deprecated object."
msgstr ""

#: ../../library/warnings.rst:547
msgid "Usage::"
msgstr ""

#: ../../library/warnings.rst:549
msgid ""
"from warnings import deprecated\n"
"from typing import overload\n"
"\n"
"@deprecated(\"Use B instead\")\n"
"class A:\n"
"    pass\n"
"\n"
"@deprecated(\"Use g instead\")\n"
"def f():\n"
"    pass\n"
"\n"
"@overload\n"
"@deprecated(\"int support is deprecated\")\n"
"def g(x: int) -> int: ...\n"
"@overload\n"
"def g(x: str) -> int: ..."
msgstr ""

#: ../../library/warnings.rst:566
msgid ""
"The warning specified by *category* will be emitted at runtime on use of "
"deprecated objects. For functions, that happens on calls; for classes, on "
"instantiation and on creation of subclasses. If the *category* is ``None``, "
"no warning is emitted at runtime. The *stacklevel* determines where the "
"warning is emitted. If it is ``1`` (the default), the warning is emitted at "
"the direct caller of the deprecated object; if it is higher, it is emitted "
"further up the stack. Static type checker behavior is not affected by the "
"*category* and *stacklevel* arguments."
msgstr ""

#: ../../library/warnings.rst:577
msgid ""
"The deprecation message passed to the decorator is saved in the "
"``__deprecated__`` attribute on the decorated object. If applied to an "
"overload, the decorator must be after the :func:`@overload <typing."
"overload>` decorator for the attribute to exist on the overload as returned "
"by :func:`typing.get_overloads`."
msgstr ""

#: ../../library/warnings.rst:584
msgid "See :pep:`702`."
msgstr ""

#: ../../library/warnings.rst:589
msgid "Available Context Managers"
msgstr ""

#: ../../library/warnings.rst:593
msgid ""
"A context manager that copies and, upon exit, restores the warnings filter "
"and the :func:`showwarning` function. If the *record* argument is :const:"
"`False` (the default) the context manager returns :class:`None` on entry. If "
"*record* is :const:`True`, a list is returned that is progressively "
"populated with objects as seen by a custom :func:`showwarning` function "
"(which also suppresses output to ``sys.stdout``). Each object in the list "
"has attributes with the same names as the arguments to :func:`showwarning`."
msgstr ""

#: ../../library/warnings.rst:602
msgid ""
"The *module* argument takes a module that will be used instead of the module "
"returned when you import :mod:`warnings` whose filter will be protected. "
"This argument exists primarily for testing the :mod:`warnings` module itself."
msgstr ""

#: ../../library/warnings.rst:607
msgid ""
"If the *action* argument is not ``None``, the remaining arguments are passed "
"to :func:`simplefilter` as if it were called immediately on entering the "
"context."
msgstr ""

#: ../../library/warnings.rst:611
msgid ""
"See :ref:`warning-filter` for the meaning of the *category* and *lineno* "
"parameters."
msgstr ""

#: ../../library/warnings.rst:616
msgid ""
"The :class:`catch_warnings` manager works by replacing and then later "
"restoring the module's :func:`showwarning` function and internal list of "
"filter specifications.  This means the context manager is modifying global "
"state and therefore is not thread-safe."
msgstr ""

#: ../../library/warnings.rst:624
msgid "Added the *action*, *category*, *lineno*, and *append* parameters."
msgstr "新增 *action*、*category*、*lineno* 和 *append* 參數。"

#: ../../library/warnings.rst:9
msgid "warnings"
msgstr "warnings （警告）"