-
-
Notifications
You must be signed in to change notification settings - Fork 37
Expand file tree
/
Copy pathannotations.po
More file actions
501 lines (449 loc) · 22.9 KB
/
annotations.po
File metadata and controls
501 lines (449 loc) · 22.9 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2001 Python Software Foundation
# This file is distributed under the same license as the Python package.
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
#
# Translators:
# python-doc bot, 2025
# digdugdog, 2026
#
#, fuzzy
msgid ""
msgstr ""
"Project-Id-Version: Python 3.14\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2026-03-07 14:18+0000\n"
"PO-Revision-Date: 2025-09-16 00:00+0000\n"
"Last-Translator: digdugdog, 2026\n"
"Language-Team: Japanese (https://app.transifex.com/python-doc/teams/5390/"
"ja/)\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Language: ja\n"
"Plural-Forms: nplurals=1; plural=0;\n"
#: ../../howto/annotations.rst:5
msgid "Annotations Best Practices"
msgstr "アノテーションのベストプラクティス"
#: ../../howto/annotations.rst:0
msgid "author"
msgstr "author"
#: ../../howto/annotations.rst:7
msgid "Larry Hastings"
msgstr "Larry Hastings"
#: ../../howto/annotations.rst-1
msgid "Abstract"
msgstr "概要"
#: ../../howto/annotations.rst:11
msgid ""
"This document is designed to encapsulate the best practices for working with "
"annotations dicts. If you write Python code that examines "
"``__annotations__`` on Python objects, we encourage you to follow the "
"guidelines described below."
msgstr ""
"このドキュメントは、アノテーションの辞書を扱う上でのベストプラクティスをまと"
"めるものです。Python オブジェクトに付与された ``__annotations__`` を Python "
"コードからアクセスする際には、以下のガイドラインに従うことを推奨します。"
#: ../../howto/annotations.rst:16
msgid ""
"The document is organized into four sections: best practices for accessing "
"the annotations of an object in Python versions 3.10 and newer, best "
"practices for accessing the annotations of an object in Python versions 3.9 "
"and older, other best practices for ``__annotations__`` that apply to any "
"Python version, and quirks of ``__annotations__``."
msgstr ""
"本ドキュメントは次の４セクションで構成されています。Python 3.10 以降でオブ"
"ジェクトのアノテーションにアクセスするときのベストプラクティス、Python 3.9 以"
"下でオブジェクトのアノテーションにアクセスするときのベストプラクティス、"
"Python バージョンに関わらない ``__annotations__`` に関するベストプラクティ"
"ス、 ``__annotations__`` の注意点、です。"
#: ../../howto/annotations.rst:26
msgid ""
"Note that this document is specifically about working with "
"``__annotations__``, not uses *for* annotations. If you're looking for "
"information on how to use \"type hints\" in your code, please see the :mod:"
"`typing` module."
msgstr ""
"注意：本ドキュメントは、アノテーションの使い方ではなく、 ``__annotations__`` "
"の使い方を扱っています。型ヒントをコードの中でどうやって使うかについては、 :"
"mod:`typing` モジュールを参照してください。"
#: ../../howto/annotations.rst:33
msgid "Accessing The Annotations Dict Of An Object In Python 3.10 And Newer"
msgstr "オブジェクトのアノテーション辞書へのアクセス (Python 3.10 以降)"
#: ../../howto/annotations.rst:35
msgid ""
"Python 3.10 adds a new function to the standard library: :func:`inspect."
"get_annotations`. In Python versions 3.10 through 3.13, calling this "
"function is the best practice for accessing the annotations dict of any "
"object that supports annotations. This function can also \"un-stringize\" "
"stringized annotations for you."
msgstr ""
"Python 3.10 で標準ライブラリに :func:`inspect.get_annotations` 関数が新たに追"
"加されました。Python 3.10 から 3.13 までは、アノテーションに対応しているオブ"
"ジェクトのアノテーション辞書にアクセスするには、この関数を使うのが一番良いで"
"す。文字列で指定されたアノテーションも自動的に文字列でない値に解決してくれま"
"す。"
#: ../../howto/annotations.rst:42
msgid ""
"In Python 3.14, there is a new :mod:`annotationlib` module with "
"functionality for working with annotations. This includes a :func:"
"`annotationlib.get_annotations` function, which supersedes :func:`inspect."
"get_annotations`."
msgstr ""
"Python 3.14 では、アノテーションを扱うためのモジュール :mod:`annotationlib` "
"が追加されました。このモジュールに :func:`annotationlib.get_annotations` があ"
"り、 :func:`inspect.get_annotations` を置き換えるものです。"
#: ../../howto/annotations.rst:47
msgid ""
"If for some reason :func:`inspect.get_annotations` isn't viable for your use "
"case, you may access the ``__annotations__`` data member manually. Best "
"practice for this changed in Python 3.10 as well: as of Python 3.10, ``o."
"__annotations__`` is guaranteed to *always* work on Python functions, "
"classes, and modules. If you're certain the object you're examining is one "
"of these three *specific* objects, you may simply use ``o.__annotations__`` "
"to get at the object's annotations dict."
msgstr ""
"もし何らかの理由で自分の用途に :func:`inspect.get_annotations` が合わないとい"
"う場合は、手動で ``__annotations__`` にアクセスすることもできます。これについ"
"ても、推奨のアクセス方法が Python 3.10 で変わりました。3.10 で、 ``o."
"__annotations__`` は関数、クラス、モジュールに対しては必ず使えることが保証さ"
"れるようになりました。オブジェクトが確実にこの３つのいずれかである場合は、単"
"に ``o.__annotations__`` を使えばアノテーション辞書を取得できます。"
#: ../../howto/annotations.rst:57
msgid ""
"However, other types of callables--for example, callables created by :func:"
"`functools.partial`--may not have an ``__annotations__`` attribute defined. "
"When accessing the ``__annotations__`` of a possibly unknown object, best "
"practice in Python versions 3.10 and newer is to call :func:`getattr` with "
"three arguments, for example ``getattr(o, '__annotations__', None)``."
msgstr ""
"しかし、それ以外の callable (例えば、 :func:`functools.partial` で作られたも"
"の) は ``__annotations__`` 属性が定義されていない可能性があります。この属性が"
"あるかどうか不明なオブジェクトの場合は、Python 3.10 以降では、 :func:"
"`getattr` に３つの引数を渡して呼び出す (例えば ``getattr(o, "
"'__annotations__', None)`` ) のを推奨します。"
#: ../../howto/annotations.rst:65
msgid ""
"Before Python 3.10, accessing ``__annotations__`` on a class that defines no "
"annotations but that has a parent class with annotations would return the "
"parent's ``__annotations__``. In Python 3.10 and newer, the child class's "
"annotations will be an empty dict instead."
msgstr ""
"Python 3.10 より前のバージョンでは、親クラスにアノテーションがあるが自身はア"
"ノテーションを定義していないようなクラスの場合、 ``__annotations__`` を取得す"
"ると親クラスの ``__annotations__`` が返されます。3.10 以降では、代わりに空の"
"辞書が返されます。"
#: ../../howto/annotations.rst:73
msgid "Accessing The Annotations Dict Of An Object In Python 3.9 And Older"
msgstr "オブジェクトのアノテーション辞書へのアクセス (Python 3.9 以前)"
#: ../../howto/annotations.rst:75
msgid ""
"In Python 3.9 and older, accessing the annotations dict of an object is much "
"more complicated than in newer versions. The problem is a design flaw in "
"these older versions of Python, specifically to do with class annotations."
msgstr ""
"Python 3.9 以前では、オブジェクトのアノテーション辞書を取得するのはより複雑で"
"す。原因は、3.9 以前のバージョンの設計上の欠陥 (具体的にはクラスのアノテー"
"ション) です。"
#: ../../howto/annotations.rst:80
msgid ""
"Best practice for accessing the annotations dict of other objects--"
"functions, other callables, and modules--is the same as best practice for "
"3.10, assuming you aren't calling :func:`inspect.get_annotations`: you "
"should use three-argument :func:`getattr` to access the object's "
"``__annotations__`` attribute."
msgstr ""
"クラス以外のオブジェクト (関数や他の callable、モジュール) のアノテーションを"
"取得する推奨の方法は、3.10と同じです。 :func:`inspect.get_annotations` ではな"
"く、 :func:`getattr` に３つの引数を渡すことで ``__annotations__`` 属性を取得"
"するのがいいです。"
#: ../../howto/annotations.rst:87
msgid ""
"Unfortunately, this isn't best practice for classes. The problem is that, "
"since ``__annotations__`` is optional on classes, and because classes can "
"inherit attributes from their base classes, accessing the "
"``__annotations__`` attribute of a class may inadvertently return the "
"annotations dict of a *base class.* As an example::"
msgstr ""
"ただし、クラスについては推奨方法が異なります。なぜなら、クラスには "
"``__annotations__`` は必須ではなく、属性はベースクラスから継承されるので、 "
"``__annotations__`` 属性にアクセスするとベースクラスのアノテーション辞書を取"
"得してしまうという問題があるからです。例えば::"
#: ../../howto/annotations.rst:94
msgid ""
"class Base:\n"
" a: int = 3\n"
" b: str = 'abc'\n"
"\n"
"class Derived(Base):\n"
" pass\n"
"\n"
"print(Derived.__annotations__)"
msgstr ""
"class Base:\n"
" a: int = 3\n"
" b: str = 'abc'\n"
"\n"
"class Derived(Base):\n"
" pass\n"
"\n"
"print(Derived.__annotations__)"
#: ../../howto/annotations.rst:103
msgid "This will print the annotations dict from ``Base``, not ``Derived``."
msgstr ""
"このコードでは ``Derived`` ではなく ``Base`` のアノテーションが表示されます。"
#: ../../howto/annotations.rst:106
msgid ""
"Your code will have to have a separate code path if the object you're "
"examining is a class (``isinstance(o, type)``). In that case, best practice "
"relies on an implementation detail of Python 3.9 and before: if a class has "
"annotations defined, they are stored in the class's :attr:`~type.__dict__` "
"dictionary. Since the class may or may not have annotations defined, best "
"practice is to call the :meth:`~dict.get` method on the class dict."
msgstr ""
"クラス (``isinstance(o, type)``) のアノテーションを取得するためには、新たに分"
"岐を追加する必要があります。推奨する方法では、 Python 3.9 以前の実装に依存し"
"た方法をとります。クラスにアノテーションがあれば、 :attr:`~type.__dict__` の"
"辞書に格納されるという実装になっています。クラスにはアノテーションがない場合"
"もあるため、この辞書の :meth:`~dict.get` メソッドを使ってアノテーションを取得"
"する、というのが推奨の方法です。"
#: ../../howto/annotations.rst:114
msgid ""
"To put it all together, here is some sample code that safely accesses the "
"``__annotations__`` attribute on an arbitrary object in Python 3.9 and "
"before::"
msgstr ""
"以上を踏まえると、Python 3.9 以前では、以下のサンプルコードで任意のオブジェク"
"トの ``__annotations__`` 属性を安全に取得することができます::"
#: ../../howto/annotations.rst:118
msgid ""
"if isinstance(o, type):\n"
" ann = o.__dict__.get('__annotations__', None)\n"
"else:\n"
" ann = getattr(o, '__annotations__', None)"
msgstr ""
"if isinstance(o, type):\n"
" ann = o.__dict__.get('__annotations__', None)\n"
"else:\n"
" ann = getattr(o, '__annotations__', None)"
#: ../../howto/annotations.rst:123
msgid ""
"After running this code, ``ann`` should be either a dictionary or ``None``. "
"You're encouraged to double-check the type of ``ann`` using :func:"
"`isinstance` before further examination."
msgstr ""
"このコードを実行すると、 ``ann`` の値は辞書か ``None`` となります。さらに "
"``ann`` の値を調べるには、 :func:`isinstance` で型を再度確認することを推奨し"
"ます。"
#: ../../howto/annotations.rst:128
msgid ""
"Note that some exotic or malformed type objects may not have a :attr:`~type."
"__dict__` attribute, so for extra safety you may also wish to use :func:"
"`getattr` to access :attr:`!__dict__`."
msgstr ""
"ただし、一部の特殊な型オブジェクトや不正な形式の型オブジェクトは :attr:"
"`~type.__dict__` 属性がないこともあるため、さらに安全をとるには :func:"
"`getattr` を使って :attr:`!__dict__` を取得したほうがいいです。"
#: ../../howto/annotations.rst:134
msgid "Manually Un-Stringizing Stringized Annotations"
msgstr "文字列指定のアノテーションを手動で解決する方法"
#: ../../howto/annotations.rst:136
msgid ""
"In situations where some annotations may be \"stringized\", and you wish to "
"evaluate those strings to produce the Python values they represent, it "
"really is best to call :func:`inspect.get_annotations` to do this work for "
"you."
msgstr ""
"アノテーションは文字列として指定されている場合があり、それを評価して Python "
"の値に変換するには、 :func:`inspect.get_annotations` を使うのが一番です。"
#: ../../howto/annotations.rst:142
msgid ""
"If you're using Python 3.9 or older, or if for some reason you can't use :"
"func:`inspect.get_annotations`, you'll need to duplicate its logic. You're "
"encouraged to examine the implementation of :func:`inspect.get_annotations` "
"in the current Python version and follow a similar approach."
msgstr ""
"Python 3.9 以前を使っているか、もしくは何らかの理由で :func:`inspect."
"get_annotations` を使えない場合は、自分で実装する必要があります。現状の "
"Python バージョンの :func:`inspect.get_annotations` の実装を確認して、同様の"
"処理を実装することを推奨します。"
#: ../../howto/annotations.rst:148
msgid ""
"In a nutshell, if you wish to evaluate a stringized annotation on an "
"arbitrary object ``o``:"
msgstr ""
"すなわち、任意のオブジェクト ``o`` の文字列アノテーションを評価するには:"
#: ../../howto/annotations.rst:151
msgid ""
"If ``o`` is a module, use ``o.__dict__`` as the ``globals`` when calling :"
"func:`eval`."
msgstr ""
"``o`` がモジュールならば、 ``o.__dict__`` を ``globals`` として :func:`eval` "
"を呼ぶ。"
#: ../../howto/annotations.rst:153
msgid ""
"If ``o`` is a class, use ``sys.modules[o.__module__].__dict__`` as the "
"``globals``, and ``dict(vars(o))`` as the ``locals``, when calling :func:"
"`eval`."
msgstr ""
"``o`` がクラスならば、 ``sys.modules[o.__module__].__dict__`` を ``globals`` "
"とし、 ``dict(vars(o))`` を ``locals`` として :func:`eval` を呼ぶ。"
#: ../../howto/annotations.rst:156
msgid ""
"If ``o`` is a wrapped callable using :func:`functools.update_wrapper`, :func:"
"`functools.wraps`, or :func:`functools.partial`, iteratively unwrap it by "
"accessing either ``o.__wrapped__`` or ``o.func`` as appropriate, until you "
"have found the root unwrapped function."
msgstr ""
"``o`` が :func:`functools.update_wrapper` か :func:`functools.wraps` か :"
"func:`functools.partial` でラップされた callable ならば、一番内部の関数に到達"
"するまで、 ``o.__wrapped__`` か ``o.func`` のどちらかを繰り返し取得する。"
#: ../../howto/annotations.rst:160
msgid ""
"If ``o`` is a callable (but not a class), use :attr:`o.__globals__ <function."
"__globals__>` as the globals when calling :func:`eval`."
msgstr ""
"``o`` がクラス以外の callable であれば、 :attr:`o.__globals__ <function."
"__globals__>` を globals として :func:`eval` を呼ぶ。"
#: ../../howto/annotations.rst:164
msgid ""
"However, not all string values used as annotations can be successfully "
"turned into Python values by :func:`eval`. String values could theoretically "
"contain any valid string, and in practice there are valid use cases for type "
"hints that require annotating with string values that specifically *can't* "
"be evaluated. For example:"
msgstr ""
"しかし、必ずしもアノテーションの文字列が :func:`eval` で Python の値に変換で"
"きるとは限りません。理論上どんな文字列も指定可能であり、変換できない文字列を"
"型ヒントとして指定する必要がある場合が実際にあります。例えば:"
#: ../../howto/annotations.rst:171
msgid ""
":pep:`604` union types using ``|``, before support for this was added to "
"Python 3.10."
msgstr ""
"``|`` を使った :pep:`604` のユニオン型 (これが追加された Python 3.10 より前の"
"バージョン)"
#: ../../howto/annotations.rst:173
msgid ""
"Definitions that aren't needed at runtime, only imported when :const:`typing."
"TYPE_CHECKING` is true."
msgstr ""
":const:`typing.TYPE_CHECKING` が True の時だけインポートされ、実行時には必要"
"ない型定義。"
#: ../../howto/annotations.rst:176
msgid ""
"If :func:`eval` attempts to evaluate such values, it will fail and raise an "
"exception. So, when designing a library API that works with annotations, "
"it's recommended to only attempt to evaluate string values when explicitly "
"requested to by the caller."
msgstr ""
":func:`eval` で上記のような値を評価しようとすると、失敗し例外が発生します。そ"
"のため、アノテーションを扱うライブラリ API を作る際は、呼び出し側が明示的に要"
"求したときのみ、文字列を評価することが推奨されます。"
#: ../../howto/annotations.rst:184
msgid "Best Practices For ``__annotations__`` In Any Python Version"
msgstr "``__annotations__`` のベストプラクティス (全 Python バージョン共通)"
#: ../../howto/annotations.rst:186
msgid ""
"You should avoid assigning to the ``__annotations__`` member of objects "
"directly. Let Python manage setting ``__annotations__``."
msgstr ""
"オブジェクトの ``__annotations__`` 属性に直接代入することは避けるべきです。"
"Python に任せましょう。 "
#: ../../howto/annotations.rst:189
msgid ""
"If you do assign directly to the ``__annotations__`` member of an object, "
"you should always set it to a ``dict`` object."
msgstr ""
"直接 ``__annotations__`` 属性に代入するなら、必ず ``dict`` オブジェクトを代入"
"するべきです。"
#: ../../howto/annotations.rst:192
msgid ""
"You should avoid accessing ``__annotations__`` directly on any object. "
"Instead, use :func:`annotationlib.get_annotations` (Python 3.14+) or :func:"
"`inspect.get_annotations` (Python 3.10+)."
msgstr ""
"どういうオブジェクトかに関わらず、直接 ``__annotations__`` にアクセスするのは"
"避けるべきです。Python 3.14 以降は :func:`annotationlib.get_annotations` 、 "
"Python 3.10 以降は :func:`inspect.get_annotations` を使いましょう。"
#: ../../howto/annotations.rst:196
msgid ""
"If you do directly access the ``__annotations__`` member of an object, you "
"should ensure that it's a dictionary before attempting to examine its "
"contents."
msgstr ""
"直接 ``__annotations__`` メンバーにアクセスするなら、まず値が辞書であることを"
"チェックしてから中身を調べるべきです。"
#: ../../howto/annotations.rst:200
msgid "You should avoid modifying ``__annotations__`` dicts."
msgstr "``__annotations__`` 辞書を書き換えるのは避けるべきです。"
#: ../../howto/annotations.rst:202
msgid ""
"You should avoid deleting the ``__annotations__`` attribute of an object."
msgstr "``__annotations__`` 属性を削除するのは避けるべきです。"
#: ../../howto/annotations.rst:207
msgid "``__annotations__`` Quirks"
msgstr "``__annotations__`` の注意点"
#: ../../howto/annotations.rst:209
msgid ""
"In all versions of Python 3, function objects lazy-create an annotations "
"dict if no annotations are defined on that object. You can delete the "
"``__annotations__`` attribute using ``del fn.__annotations__``, but if you "
"then access ``fn.__annotations__`` the object will create a new empty dict "
"that it will store and return as its annotations. Deleting the annotations "
"on a function before it has lazily created its annotations dict will throw "
"an ``AttributeError``; using ``del fn.__annotations__`` twice in a row is "
"guaranteed to always throw an ``AttributeError``."
msgstr ""
#: ../../howto/annotations.rst:219
msgid ""
"Everything in the above paragraph also applies to class and module objects "
"in Python 3.10 and newer."
msgstr ""
#: ../../howto/annotations.rst:222
msgid ""
"In all versions of Python 3, you can set ``__annotations__`` on a function "
"object to ``None``. However, subsequently accessing the annotations on that "
"object using ``fn.__annotations__`` will lazy-create an empty dictionary as "
"per the first paragraph of this section. This is *not* true of modules and "
"classes, in any Python version; those objects permit setting "
"``__annotations__`` to any Python value, and will retain whatever value is "
"set."
msgstr ""
#: ../../howto/annotations.rst:230
msgid ""
"If Python stringizes your annotations for you (using ``from __future__ "
"import annotations``), and you specify a string as an annotation, the string "
"will itself be quoted. In effect the annotation is quoted *twice.* For "
"example::"
msgstr ""
#: ../../howto/annotations.rst:236
msgid ""
"from __future__ import annotations\n"
"def foo(a: \"str\"): pass\n"
"\n"
"print(foo.__annotations__)"
msgstr ""
#: ../../howto/annotations.rst:241
msgid ""
"This prints ``{'a': \"'str'\"}``. This shouldn't really be considered a "
"\"quirk\"; it's mentioned here simply because it might be surprising."
msgstr ""
#: ../../howto/annotations.rst:244
msgid ""
"If you use a class with a custom metaclass and access ``__annotations__`` on "
"the class, you may observe unexpected behavior; see :pep:`749 <749#pep749-"
"metaclasses>` for some examples. You can avoid these quirks by using :func:"
"`annotationlib.get_annotations` on Python 3.14+ or :func:`inspect."
"get_annotations` on Python 3.10+. On earlier versions of Python, you can "
"avoid these bugs by accessing the annotations from the class's :attr:`~type."
"__dict__` (for example, ``cls.__dict__.get('__annotations__', None)``)."
msgstr ""
#: ../../howto/annotations.rst:253
msgid ""
"In some versions of Python, instances of classes may have an "
"``__annotations__`` attribute. However, this is not supported functionality. "
"If you need the annotations of an instance, you can use :func:`type` to "
"access its class (for example, ``annotationlib."
"get_annotations(type(myinstance))`` on Python 3.14+)."
msgstr ""