python-docs-ro/howto/annotations.po at 3.13 · python/python-docs-ro

361 lines (312 loc) · 12.3 KB
# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2001-2025, Python Software Foundation
# This file is distributed under the same license as the Python package.
# FIRST AUTHOR <EMAIL@ADDRESS>, 2025.
"Project-Id-Version: Python 3.13\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2025-03-04 13:08+0200\n"
"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
"Language: ro\n"
"Language-Team: ro <LL@li.org>\n"
"Plural-Forms: nplurals=3; plural=(n==1 ? 0 : (n==0 || (n%100 > 0 && n%100"
" < 20)) ? 1 : 2);\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=utf-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Generated-By: Babel 2.17.0\n"
#: ../../howto/annotations.rst:5
msgid "Annotations Best Practices"
#: ../../howto/annotations.rst
msgid "author"
#: ../../howto/annotations.rst:7
msgid "Larry Hastings"
#: ../../howto/annotations.rst:-1
msgid "Abstract"
#: ../../howto/annotations.rst:11
"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."
#: ../../howto/annotations.rst:16
"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__``."
#: ../../howto/annotations.rst:26
"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."
#: ../../howto/annotations.rst:33
msgid "Accessing The Annotations Dict Of An Object In Python 3.10 And Newer"
#: ../../howto/annotations.rst:35
"Python 3.10 adds a new function to the standard library: "
":func:`inspect.get_annotations`.  In Python versions 3.10 and newer, "
"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."
#: ../../howto/annotations.rst:42
"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."
#: ../../howto/annotations.rst:52
"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)``."
#: ../../howto/annotations.rst:60
"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."
#: ../../howto/annotations.rst:68
msgid "Accessing The Annotations Dict Of An Object In Python 3.9 And Older"
#: ../../howto/annotations.rst:70
"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."
#: ../../howto/annotations.rst:75
"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."
#: ../../howto/annotations.rst:82
"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::"
#: ../../howto/annotations.rst:89
"class Base:\n"
"    a: int = 3\n"
"    b: str = 'abc'\n"
"class Derived(Base):\n"
"    pass\n"
"print(Derived.__annotations__)"
#: ../../howto/annotations.rst:98
msgid "This will print the annotations dict from ``Base``, not ``Derived``."
#: ../../howto/annotations.rst:101
"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."
#: ../../howto/annotations.rst:109
"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 "
#: ../../howto/annotations.rst:113
"if isinstance(o, type):\n"
"    ann = o.__dict__.get('__annotations__', None)\n"
"    ann = getattr(o, '__annotations__', None)"
#: ../../howto/annotations.rst:118
"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."
#: ../../howto/annotations.rst:123
"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__`."
#: ../../howto/annotations.rst:129
msgid "Manually Un-Stringizing Stringized Annotations"
#: ../../howto/annotations.rst:131
"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 "
#: ../../howto/annotations.rst:137
"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."
#: ../../howto/annotations.rst:143
"In a nutshell, if you wish to evaluate a stringized annotation on an "
"arbitrary object ``o``:"
#: ../../howto/annotations.rst:146
"If ``o`` is a module, use ``o.__dict__`` as the ``globals`` when calling "
":func:`eval`."
#: ../../howto/annotations.rst:148
"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`."
#: ../../howto/annotations.rst:151
"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."
#: ../../howto/annotations.rst:155
"If ``o`` is a callable (but not a class), use :attr:`o.__globals__ "
"<function.__globals__>` as the globals when calling :func:`eval`."
#: ../../howto/annotations.rst:159
"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:"
#: ../../howto/annotations.rst:166
":pep:`604` union types using ``|``, before support for this was added to "
"Python 3.10."
#: ../../howto/annotations.rst:168
"Definitions that aren't needed at runtime, only imported when "
":const:`typing.TYPE_CHECKING` is true."
#: ../../howto/annotations.rst:171
"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."
#: ../../howto/annotations.rst:179
msgid "Best Practices For ``__annotations__`` In Any Python Version"
#: ../../howto/annotations.rst:181
"You should avoid assigning to the ``__annotations__`` member of objects "
"directly.  Let Python manage setting ``__annotations__``."
#: ../../howto/annotations.rst:184
"If you do assign directly to the ``__annotations__`` member of an object,"
" you should always set it to a ``dict`` object."
#: ../../howto/annotations.rst:187
"If you directly access the ``__annotations__`` member of an object, you "
"should ensure that it's a dictionary before attempting to examine its "
"contents."
#: ../../howto/annotations.rst:191
msgid "You should avoid modifying ``__annotations__`` dicts."
#: ../../howto/annotations.rst:193
msgid "You should avoid deleting the ``__annotations__`` attribute of an object."
#: ../../howto/annotations.rst:198
msgid "``__annotations__`` Quirks"
#: ../../howto/annotations.rst:200
"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``."
#: ../../howto/annotations.rst:210
"Everything in the above paragraph also applies to class and module "
"objects in Python 3.10 and newer."
#: ../../howto/annotations.rst:213
"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."
#: ../../howto/annotations.rst:221
"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::"
#: ../../howto/annotations.rst:227
"from __future__ import annotations\n"
"def foo(a: \"str\"): pass\n"
"print(foo.__annotations__)"
#: ../../howto/annotations.rst:232
#, python-brace-format
"This prints ``{'a': \"'str'\"}``.  This shouldn't really be considered a "
"\"quirk\"; it's mentioned here simply because it might be surprising."
Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Uh oh!

Uh oh!

FilesExpand file tree

annotations.po

Latest commit

History

annotations.po

File metadata and controls
