python
diff --git a/‎howto/descriptor.po‎
Lines changed: 131 additions & 78 deletions b/‎howto/descriptor.po‎
Lines changed: 131 additions & 78 deletions
@@ -13,7 +13,7 @@ msgid ""
 msgstr ""
 "Project-Id-Version: Python 3.9\n"
 "Report-Msgid-Bugs-To: \n"
-"POT-Creation-Date: 2020-10-24 04:26+0000\n"
+"POT-Creation-Date: 2020-10-25 04:26+0000\n"
 "PO-Revision-Date: 2017-02-16 17:44+0000\n"
 "Last-Translator: m_aciek <maciej.olko@gmail.com>, 2020\n"
 "Language-Team: Polish (https://www.transifex.com/python-doc/teams/5390/pl/)\n"
@@ -71,8 +71,8 @@ msgid "Primer"
 msgstr ""
 
 msgid ""
-"In this primer, we start with most basic possible example and then we'll add "
-"new capabilities one by one."
+"In this primer, we start with the most basic possible example and then we'll "
+"add new capabilities one by one."
 msgstr ""
 
 msgid "Simple example: A descriptor that returns a constant"
@@ -197,6 +197,12 @@ msgid ""
 "`__get__`, :meth:`__set__`, or :meth:`__delete__`."
 msgstr ""
 
+msgid ""
+"Optionally, descriptors can have a :meth:`__set_name__` method.  This is "
+"only used in cases where a descriptor needs to know either the class where "
+"it is created or the name of class variable it was assigned to."
+msgstr ""
+
 msgid ""
 "Descriptors get invoked by the dot operator during attribute lookup.  If a "
 "descriptor is accessed indirectly with ``vars(some_class)"
@@ -241,7 +247,7 @@ msgid ""
 "A validator is a descriptor for managed attribute access.  Prior to storing "
 "any data, it verifies that the new value meets various type and range "
 "restrictions.  If those restrictions aren't met, it raises an exception to "
-"prevents data corruption at its source."
+"prevent data corruption at its source."
 msgstr ""
 
 msgid ""
@@ -318,18 +324,18 @@ msgid ""
 "one whose attribute access has been overridden by methods in the descriptor "
 "protocol.  Those methods are :meth:`__get__`, :meth:`__set__`, and :meth:"
 "`__delete__`.  If any of those methods are defined for an object, it is said "
-"to be a descriptor."
+"to be a :term:`descriptor`."
 msgstr ""
 
 msgid ""
 "The default behavior for attribute access is to get, set, or delete the "
 "attribute from an object's dictionary.  For instance, ``a.x`` has a lookup "
 "chain starting with ``a.__dict__['x']``, then ``type(a).__dict__['x']``, and "
-"continuing through the base classes of ``type(a)`` excluding metaclasses. If "
-"the looked-up value is an object defining one of the descriptor methods, "
-"then Python may override the default behavior and invoke the descriptor "
-"method instead. Where this occurs in the precedence chain depends on which "
-"descriptor methods were defined."
+"continuing through the base classes of ``type(a)``. If the looked-up value "
+"is an object defining one of the descriptor methods, then Python may "
+"override the default behavior and invoke the descriptor method instead. "
+"Where this occurs in the precedence chain depends on which descriptor "
+"methods were defined."
 msgstr ""
 
 msgid ""
@@ -389,76 +395,100 @@ msgid ""
 msgstr ""
 
 msgid ""
-"Alternatively, it is more common for a descriptor to be invoked "
-"automatically upon attribute access.  For example, ``obj.d`` looks up ``d`` "
-"in the dictionary of ``obj``.  If ``d`` defines the method :meth:`__get__`, "
-"then ``d.__get__(obj)`` is invoked according to the precedence rules listed "
-"below."
+"But it is more common for a descriptor to be invoked automatically from "
+"attribute access.  The expression ``obj.d`` looks up ``d`` in the dictionary "
+"of ``obj``.  If ``d`` defines the method :meth:`__get__`, then ``d."
+"__get__(obj)`` is invoked according to the precedence rules listed below."
+msgstr ""
+
+msgid ""
+"The details of invocation depend on whether ``obj`` is an object, class, or "
+"instance of super."
+msgstr ""
+
+msgid "**Objects**:  The machinery is in :meth:`object.__getattribute__`."
+msgstr ""
+
+msgid ""
+"It transforms ``b.x`` into ``type(b).__dict__['x'].__get__(b, type(b))``."
 msgstr ""
 
 msgid ""
-"The details of invocation depend on whether ``obj`` is an object or a class."
+"The implementation works through a precedence chain that gives data "
+"descriptors priority over instance variables, instance variables priority "
+"over non-data descriptors, and assigns lowest priority to :meth:"
+"`__getattr__` if provided."
 msgstr ""
 
 msgid ""
-"For objects, the machinery is in :meth:`object.__getattribute__` which "
-"transforms ``b.x`` into ``type(b).__dict__['x'].__get__(b, type(b))``.  The "
-"implementation works through a precedence chain that gives data descriptors "
-"priority over instance variables, instance variables priority over non-data "
-"descriptors, and assigns lowest priority to :meth:`__getattr__` if provided. "
 "The full C implementation can be found in :c:func:"
 "`PyObject_GenericGetAttr()` in :source:`Objects/object.c`."
 msgstr ""
 
+msgid "**Classes**:  The machinery is in :meth:`type.__getattribute__`."
+msgstr ""
+
+msgid "It transforms ``A.x`` into ``A.__dict__['x'].__get__(None, A)``."
+msgstr ""
+
+msgid "In pure Python, it looks like this::"
+msgstr ""
+
 msgid ""
-"For classes, the machinery is in :meth:`type.__getattribute__` which "
-"transforms ``B.x`` into ``B.__dict__['x'].__get__(None, B)``.  In pure "
-"Python, it looks like::"
+"**Super**:  The machinery is in the custom :meth:`__getattribute__` method "
+"for object returned by :class:`super()`."
 msgstr ""
 
-msgid "The important points to remember are:"
+msgid ""
+"The attribute lookup ``super(A, obj).m`` searches ``obj.__class__.__mro__`` "
+"for the base class ``B`` immediately following ``A`` and then returns ``B."
+"__dict__['m'].__get__(obj, A)``."
 msgstr ""
 
-msgid "descriptors are invoked by the :meth:`__getattribute__` method"
+msgid ""
+"If not a descriptor, ``m`` is returned unchanged.  If not in the dictionary, "
+"``m`` reverts to a search using :meth:`object.__getattribute__`."
 msgstr ""
 
-msgid "overriding :meth:`__getattribute__` prevents automatic descriptor calls"
+msgid ""
+"The implementation details are in :c:func:`super_getattro()` in :source:"
+"`Objects/typeobject.c`.  A pure Python equivalent can be found in `Guido's "
+"Tutorial`_."
 msgstr ""
 
 msgid ""
-":meth:`object.__getattribute__` and :meth:`type.__getattribute__` make "
-"different calls to :meth:`__get__`."
+"**Summary**:  The details listed above show that the mechanism for "
+"descriptors is embedded in the :meth:`__getattribute__()` methods for :class:"
+"`object`, :class:`type`, and :func:`super`."
 msgstr ""
 
-msgid "data descriptors always override instance dictionaries."
+msgid "The important points to remember are:"
 msgstr ""
 
-msgid "non-data descriptors may be overridden by instance dictionaries."
+msgid "Descriptors are invoked by the :meth:`__getattribute__` method."
 msgstr ""
 
 msgid ""
-"The object returned by ``super()`` also has a custom :meth:"
-"`__getattribute__` method for invoking descriptors.  The attribute lookup "
-"``super(B, obj).m`` searches ``obj.__class__.__mro__`` for the base class "
-"``A`` immediately following ``B`` and then returns ``A.__dict__['m']."
-"__get__(obj, B)``.  If not a descriptor, ``m`` is returned unchanged.  If "
-"not in the dictionary, ``m`` reverts to a search using :meth:`object."
-"__getattribute__`."
+"Classes inherit this machinery from :class:`object`, :class:`type`, or :func:"
+"`super`."
 msgstr ""
 
 msgid ""
-"The implementation details are in :c:func:`super_getattro()` in :source:"
-"`Objects/typeobject.c`.  and a pure Python equivalent can be found in "
-"`Guido's Tutorial`_."
+"Overriding :meth:`__getattribute__` prevents automatic descriptor calls "
+"because all the descriptor logic is in that method."
 msgstr ""
 
 msgid ""
-"The details above show that the mechanism for descriptors is embedded in "
-"the :meth:`__getattribute__()` methods for :class:`object`, :class:`type`, "
-"and :func:`super`.  Classes inherit this machinery when they derive from :"
-"class:`object` or if they have a metaclass providing similar functionality. "
-"Likewise, classes can turn-off descriptor invocation by overriding :meth:"
-"`__getattribute__()`."
+":meth:`object.__getattribute__` and :meth:`type.__getattribute__` make "
+"different calls to :meth:`__get__`.  The first includes the instance and may "
+"include the class.  The second puts in ``None`` for the instance and always "
+"includes the class."
+msgstr ""
+
+msgid "Data descriptors always override instance dictionaries."
+msgstr ""
+
+msgid "Non-data descriptors may be overridden by instance dictionaries."
 msgstr ""
 
 msgid "Automatic Name Notification"
@@ -488,17 +518,32 @@ msgid "Descriptor Example"
 msgstr ""
 
 msgid ""
-"The following code creates a class whose objects are data descriptors which "
-"print a message for each get or set.  Overriding :meth:`__getattribute__` is "
-"alternate approach that could do this for every attribute.  However, this "
-"descriptor is useful for monitoring just a few chosen attributes::"
+"The following code is simplified skeleton showing how data descriptors could "
+"be used to implement an `object relational mapping <https://en.wikipedia.org/"
+"wiki/Object%E2%80%93relational_mapping>`_."
 msgstr ""
 
 msgid ""
-"The protocol is simple and offers exciting possibilities.  Several use cases "
-"are so common that they have been packaged into individual function calls. "
-"Properties, bound methods, static methods, and class methods are all based "
-"on the descriptor protocol."
+"The essential idea is that instances only hold keys to a database table.  "
+"The actual data is stored in an external table that is being dynamically "
+"updated::"
+msgstr ""
+
+msgid ""
+"We can use the :class:`Field` to define \"models\" that describe the schema "
+"for each table in a database::"
+msgstr ""
+
+msgid ""
+"An interactive session shows how data is retrieved from the database and how "
+"it can be updated::"
+msgstr ""
+
+msgid ""
+"The descriptor protocol is simple and offers exciting possibilities.  "
+"Several use cases are so common that they have been packaged into individual "
+"function calls.  Properties, bound methods, static methods, and class "
+"methods are all based on the descriptor protocol."
 msgstr ""
 
 msgid "Properties"
@@ -542,51 +587,59 @@ msgid ""
 msgstr ""
 
 msgid ""
-"Class dictionaries store methods as functions.  In a class definition, "
-"methods are written using :keyword:`def` or :keyword:`lambda`, the usual "
-"tools for creating functions.  Methods only differ from regular functions in "
-"that the first argument is reserved for the object instance.  By Python "
-"convention, the instance reference is called *self* but may be called *this* "
-"or any other variable name."
+"Functions stored in class dictionaries get turned into methods when invoked. "
+"Methods only differ from regular functions in that the object instance is "
+"prepended to the other arguments.  By convention, the instance is called "
+"*self* but could be called *this* or any other variable name."
+msgstr ""
+
+msgid ""
+"Methods can be created manually with :class:`types.MethodType` which is "
+"roughly equivalent to::"
 msgstr ""
 
 msgid ""
-"To support method calls, functions include the :meth:`__get__` method for "
-"binding methods during attribute access.  This means that all functions are "
-"non-data descriptors which return bound methods when they are invoked from "
-"an object.  In pure Python, it works like this::"
+"To support automatic creation of methods, functions include the :meth:"
+"`__get__` method for binding methods during attribute access.  This means "
+"that functions are non-data descriptors which return bound methods during "
+"dotted lookup from an instance.  Here's how it works::"
 msgstr ""
 
 msgid ""
-"Running the following in class in the interpreter shows how the function "
+"Running the following class in the interpreter shows how the function "
 "descriptor works in practice::"
 msgstr ""
 
 msgid ""
-"Access through the class dictionary does not invoke :meth:`__get__`.  "
-"Instead, it just returns the underlying function object::"
+"The function has a :term:`qualified name` attribute to support "
+"introspection::"
 msgstr ""
 
 msgid ""
-"Dotted access from a class calls :meth:`__get__` which just returns the "
-"underlying function unchanged::"
+"Accessing the function through the class dictionary does not invoke :meth:"
+"`__get__`.  Instead, it just returns the underlying function object::"
 msgstr ""
 
 msgid ""
-"The function has a :term:`qualified name` attribute to support "
-"introspection::"
+"Dotted access from a class calls :meth:`__get__` which just returns the "
+"underlying function unchanged::"
 msgstr ""
 
 msgid ""
-"Dotted access from an instance calls :meth:`__get__` which returns a bound "
-"method object::"
+"The interesting behavior occurs during dotted access from an instance.  The "
+"dotted lookup calls :meth:`__get__` which returns a bound method object::"
 msgstr ""
 
 msgid ""
 "Internally, the bound method stores the underlying function and the bound "
 "instance::"
 msgstr ""
 
+msgid ""
+"If you have ever wondered where *self* comes from in regular methods or "
+"where *cls* comes from in class methods, this is it!"
+msgstr ""
+
 msgid "Static Methods and Class Methods"
 msgstr ""
 
@@ -660,7 +713,7 @@ msgid ""
 msgstr ""
 
 msgid ""
-"Since staticmethods return the underlying function with no changes, the "
+"Since static methods return the underlying function with no changes, the "
 "example calls are unexciting::"
 msgstr ""
 
@@ -677,9 +730,9 @@ msgstr ""
 
 msgid ""
 "This behavior is useful whenever the function only needs to have a class "
-"reference and does not care about any underlying data.  One use for "
-"classmethods is to create alternate class constructors.  The classmethod :"
-"func:`dict.fromkeys` creates a new dictionary from a list of keys.  The pure "
+"reference and does not care about any underlying data.  One use for class "
+"methods is to create alternate class constructors.  The classmethod :func:"
+"`dict.fromkeys` creates a new dictionary from a list of keys.  The pure "
 "Python equivalent is::"
 msgstr ""