Update additional Punjabi documentation translations

Author: BHUVANSH855

c-api/picklebuffer.po

@@ -61,8 +61,8 @@ msgid ""
 "On success, return a new pickle buffer instance. On failure, set an "
 "exception and return ``NULL``."
 msgstr ""
-"ਸਫਲ ਹੋਣ 'ਤੇ, ਇੱਕ ਨਵਾਂ pickle buffer ਇੰਸਟੈਂਸ ਵਾਪਸ ਕਰੋ। ਅਸਫਲ ਹੋਣ 'ਤੇ, ਇੱਕ ਅਪਵਾਦ ਸੈੱਟ ਕਰੋ ਅਤੇ "
-"``NULL`` ਵਾਪਸ ਕਰੋ।"
+"ਸਫਲ ਹੋਣ 'ਤੇ, ਇੱਕ ਨਵਾਂ pickle buffer instance ਵਾਪਸ ਕਰੋ। ਅਸਫਲ ਹੋਣ 'ਤੇ, ਇੱਕ exception "
+"ਸੈੱਟ ਕਰੋ ਅਤੇ ``NULL`` ਵਾਪਸ ਕਰੋ।"
 
 msgid "Analogous to calling :class:`pickle.PickleBuffer` with *obj* in Python."
 msgstr ""
@@ -88,15 +88,15 @@ msgid ""
 "On success, return a pointer to the buffer view. On failure, set an "
 "exception and return ``NULL``."
 msgstr ""
-"ਸਫਲ ਹੋਣ 'ਤੇ, ਬਫ਼ਰ ਦ੍ਰਿਸ਼ ਲਈ ਇੱਕ ਪੁਆਇੰਟਰ ਵਾਪਸ ਕਰੋ। ਅਸਫਲ ਹੋਣ 'ਤੇ, ਇੱਕ ਅਪਵਾਦ ਸੈੱਟ ਕਰੋ ਅਤੇ "
-"``NULL`` ਵਾਪਸ ਕਰੋ।"
+"ਸਫਲ ਹੋਣ 'ਤੇ, buffer view ਲਈ ਇੱਕ pointer ਵਾਪਸ ਕਰੋ। ਅਸਫਲ ਹੋਣ 'ਤੇ, ਇੱਕ exception ਸੈੱਟ "
+"ਕਰੋ ਅਤੇ ``NULL`` ਵਾਪਸ ਕਰੋ।"
 
 msgid "Release the underlying buffer held by the pickle buffer."
 msgstr "pickle buffer ਦੁਆਰਾ ਰੱਖੇ ਗਏ ਅੰਦਰੂਨੀ ਬਫ਼ਰ ਨੂੰ ਜਾਰੀ ਕਰੋ।"
 
 msgid ""
 "Return ``0`` on success. On failure, set an exception and return ``-1``."
-msgstr "ਸਫਲ ਹੋਣ 'ਤੇ ``0`` ਵਾਪਸ ਕਰੋ। ਅਸਫਲ ਹੋਣ 'ਤੇ, ਇੱਕ ਅਪਵਾਦ ਸੈੱਟ ਕਰੋ ਅਤੇ ``-1`` ਵਾਪਸ ਕਰੋ।"
+msgstr "ਸਫਲ ਹੋਣ 'ਤੇ ``0`` ਵਾਪਸ ਕਰੋ। ਅਸਫਲ ਹੋਣ 'ਤੇ, ਇੱਕ exception ਸੈੱਟ ਕਰੋ ਅਤੇ ``-1`` ਵਾਪਸ ਕਰੋ।"
 
 msgid "Analogous to calling :meth:`pickle.PickleBuffer.release` in Python."
 msgstr "ਇਹ Python ਵਿੱਚ :meth:`pickle.PickleBuffer.release` ਨੂੰ ਕਾਲ ਕਰਨ ਦੇ ਸਮਾਨ ਹੈ।"

deprecations/pending-removal-in-3.20.po

@@ -78,7 +78,7 @@ msgid ":mod:`json`"
 msgstr ":mod:`json`"
 
 msgid ":mod:`logging` (``__date__`` also deprecated)"
-msgstr ""
+msgstr ":mod:`logging` (``__date__`` ਵੀ ਡਿਪ੍ਰੀਕੇਟ ਕੀਤਾ ਗਿਆ ਹੈ)"
 
 msgid ":mod:`optparse`"
 msgstr ":mod:`optparse`"

howto/regex.po

@@ -954,9 +954,9 @@ msgstr ""
 "p = re.compile( ... )\n"
 "m = p.search( 'string goes here' )\n"
 "if m:\n"
-"print('Match found: ', m.group())\n"
+"    print('Match found: ', m.group())\n"
 "else:\n"
-"print('No match')"
+"    print('No match')"
 
 msgid ""
 "Two pattern methods return all of the matches for a pattern. :meth:`~re."
@@ -1012,7 +1012,7 @@ msgstr ""
 ">>> iterator\n"
 "<callable_iterator object at 0x...>\n"
 ">>> for match in iterator:\n"
-"... print(match.span())\n"
+"...     print(match.span())\n"
 "...\n"
 "(0, 2)\n"
 "(22, 24)\n"
@@ -1285,13 +1285,13 @@ msgid ""
 "\"\"\", re.VERBOSE)"
 msgstr ""
 "charref = re.compile(r\"\"\"\n"
-"&[#] # Start of a numeric entity reference\n"
-"(\n"
-"0[0-7]+ # Octal form\n"
-"| [0-9]+ # Decimal form\n"
-"| x[0-9a-fA-F]+ # Hexadecimal form\n"
-")\n"
-"; # Trailing semicolon\n"
+" &[#]                # Start of a numeric entity reference\n"
+" (\n"
+"     0[0-7]+         # Octal form\n"
+"   | [0-9]+          # Decimal form\n"
+"   | x[0-9a-fA-F]+   # Hexadecimal form\n"
+" )\n"
+" ;                   # Trailing semicolon\n"
 "\"\"\", re.VERBOSE)"
 
 msgid "Without the verbose setting, the RE would look like this::"
@@ -1303,8 +1303,8 @@ msgid ""
 "                     \"|x[0-9a-fA-F]+);\")"
 msgstr ""
 "charref = re.compile(\"&#(0[0-7]+\"\n"
-"\"|[0-9]+\"\n"
-"\"|x[0-9a-fA-F]+);\")"
+"                     \"|[0-9]+\"\n"
+"                     \"|x[0-9a-fA-F]+);\")"
 
 msgid ""
 "In the above example, Python's automatic concatenation of string literals "
@@ -1926,11 +1926,11 @@ msgid ""
 "        r'\"')"
 msgstr ""
 "InternalDate = re.compile(r'INTERNALDATE \"'\n"
-"r'(?P<day>[ 123][0-9])-(?P<mon>[A-Z][a-z][a-z])-'\n"
-"r'(?P<year>[0-9][0-9][0-9][0-9])'\n"
-"r' (?P<hour>[0-9][0-9]):(?P<min>[0-9][0-9]):(?P<sec>[0-9][0-9])'\n"
-"r' (?P<zonen>[-+])(?P<zoneh>[0-9][0-9])(?P<zonem>[0-9][0-9])'\n"
-"r'\"')"
+"        r'(?P<day>[ 123][0-9])-(?P<mon>[A-Z][a-z][a-z])-'\n"
+"        r'(?P<year>[0-9][0-9][0-9][0-9])'\n"
+"        r' (?P<hour>[0-9][0-9]):(?P<min>[0-9][0-9]):(?P<sec>[0-9][0-9])'\n"
+"        r' (?P<zonen>[-+])(?P<zoneh>[0-9][0-9])(?P<zonem>[0-9][0-9])'\n"
+"        r'\"')"
 
 msgid ""
 "It's obviously much easier to retrieve ``m.group('zonem')``, instead of "
@@ -2305,11 +2305,11 @@ msgid ""
 ">>> p.sub('colour', 'blue socks and red shoes', count=1)\n"
 "'colour socks and red shoes'"
 msgstr ""
-"\">>> p = re.compile('(blue|white|red)')\\n\"\n"
-"\">>> p.sub('colour', 'blue socks and red shoes')\\n\"\n"
-"\"'colour socks and colour shoes'\\n\"\n"
-"\">>> p.sub('colour', 'blue socks and red shoes', count=1)\\n\"\n"
-"\"'colour socks and red shoes'\""
+">>> p = re.compile('(blue|white|red)')\n"
+">>> p.sub('colour', 'blue socks and red shoes')\n"
+"'colour socks and colour shoes'\n"
+">>> p.sub('colour', 'blue socks and red shoes', count=1)\n"
+"'colour socks and red shoes'"
 
 msgid ""
 "The :meth:`~re.Pattern.subn` method does the same work, but returns a 2-"
@@ -2326,11 +2326,11 @@ msgid ""
 ">>> p.subn('colour', 'no colours at all')\n"
 "('no colours at all', 0)"
 msgstr ""
-"\">>> p = re.compile('(blue|white|red)')\\n\"\n"
-"\">>> p.subn('colour', 'blue socks and red shoes')\\n\"\n"
-"\"('colour socks and colour shoes', 2)\\n\"\n"
-"\">>> p.subn('colour', 'no colours at all')\\n\"\n"
-"\"('no colours at all', 0)\""
+">>> p = re.compile('(blue|white|red)')\n"
+">>> p.subn('colour', 'blue socks and red shoes')\n"
+"('colour socks and colour shoes', 2)\n"
+">>> p.subn('colour', 'no colours at all')\n"
+"('no colours at all', 0)"
 
 msgid ""
 "Empty matches are replaced only when they're not adjacent to a previous "
@@ -2403,13 +2403,13 @@ msgid ""
 ">>> p.sub(r'subsection{\\g<name>}','section{First}')\n"
 "'subsection{First}'"
 msgstr ""
-"\">>> p = re.compile('section{ (?P<name> [^}]* ) }', re.VERBOSE)\\n\"\n"
-"\">>> p.sub(r'subsection{\\\\1}','section{First}')\\n\"\n"
-"\"'subsection{First}'\\n\"\n"
-"\">>> p.sub(r'subsection{\\\\g<1>}','section{First}')\\n\"\n"
-"\"'subsection{First}'\\n\"\n"
-"\">>> p.sub(r'subsection{\\\\g<name>}','section{First}')\\n\"\n"
-"\"'subsection{First}'\""
+">>> p = re.compile('section{ (?P<name> [^}]* ) }', re.VERBOSE)\n"
+">>> p.sub(r'subsection{\\1}','section{First}')\n"
+"'subsection{First}'\n"
+">>> p.sub(r'subsection{\\g<1>}','section{First}')\n"
+"'subsection{First}'\n"
+">>> p.sub(r'subsection{\\g<name>}','section{First}')\n"
+"'subsection{First}'"
 
 msgid ""
 "*replacement* can also be a function, which gives you even more control.  If "
@@ -2441,9 +2441,9 @@ msgid ""
 "'Call 0xffd2 for printing, 0xc000 for user code.'"
 msgstr ""
 ">>> def hexrepl(match):\n"
-"... \"Return the hex string for a decimal number\"\n"
-"... value = int(match.group())\n"
-"... return hex(value)\n"
+"...     \"Return the hex string for a decimal number\"\n"
+"...     value = int(match.group())\n"
+"...     return hex(value)\n"
 "...\n"
 ">>> p = re.compile(r'\\d+')\n"
 ">>> p.sub(hexrepl, 'Call 65490 for printing, 49152 for user code.')\n"
@@ -2618,13 +2618,13 @@ msgid ""
 ">>> print(re.prefixmatch('<.*>', s).group())\n"
 "<html><head><title>Title</title>"
 msgstr ""
-"\">>> s = '<html><head><title>Title</title>'\\n\"\n"
-"\">>> len(s)\\n\"\n"
-"\"32\\n\"\n"
-"\">>> print(re.prefixmatch('<.*>', s).span())\\n\"\n"
-"\"(0, 32)\\n\"\n"
-"\">>> print(re.prefixmatch('<.*>', s).group())\\n\"\n"
-"\"<html><head><title>Title</title>\""
+">>> s = '<html><head><title>Title</title>'\n"
+">>> len(s)\n"
+"32\n"
+">>> print(re.prefixmatch('<.*>', s).span())\n"
+"(0, 32)\n"
+">>> print(re.prefixmatch('<.*>', s).group())\n"
+"<html><head><title>Title</title>"
 
 msgid ""
 "The RE matches the ``'<'`` in ``'<html>'``, and the ``.*`` consumes the rest "
@@ -2657,8 +2657,8 @@ msgid ""
 ">>> print(re.prefixmatch('<.*?>', s).group())\n"
 "<html>"
 msgstr ""
-"\">>> print(re.prefixmatch('<.*?>', s).group())\\n\"\n"
-"\"<html>\""
+">>> print(re.prefixmatch('<.*?>', s).group())\n"
+"<html>"
 
 msgid ""
 "(Note that parsing HTML or XML with regular expressions is painful. Quick-"
@@ -2722,22 +2722,20 @@ msgid ""
 " \\s*$                # Trailing whitespace to end-of-line\n"
 "\"\"\", re.VERBOSE)"
 msgstr ""
-"\"pat = re.compile(r\\\"\\\"\\\"\\n\"\n"
-"\" \\\\s* # Skip leading whitespace\\n\"\n"
-"\" (?P<header>[^:]+) # Header name\\n\"\n"
-"\" \\\\s* : # Whitespace, and a colon\\n\"\n"
-"\" (?P<value>.*?) # The header's value -- *? used to\\n\"\n"
-"\" # lose the following trailing whitespace\\n\"\n"
-"\" \\\\s*$ # Trailing whitespace to end-of-line\\n\"\n"
-"\"\\\"\\\"\\\", re.VERBOSE)\""
+"pat = re.compile(r\"\"\"\n"
+" \\s*                 # Skip leading whitespace\n"
+" (?P<header>[^:]+)   # Header name\n"
+" \\s* :               # Whitespace, and a colon\n"
+" (?P<value>.*?)      # The header's value -- *? used to\n"
+"                     # lose the following trailing whitespace\n"
+" \\s*$                # Trailing whitespace to end-of-line\n"
+"\"\"\", re.VERBOSE)"
 
 msgid "This is far more readable than::"
 msgstr "ਇਹ ਹੇਠਾਂ ਦਿੱਤੀ ਐਕਸਪ੍ਰੈਸ਼ਨ ਨਾਲੋਂ ਕਾਫ਼ੀ ਵੱਧ ਪੜ੍ਹਨਯੋਗ ਹੈ:"
 
 msgid "pat = re.compile(r\"\\s*(?P<header>[^:]+)\\s*:(?P<value>.*?)\\s*$\")"
-msgstr ""
-"\"pat = re.compile(r\\\"\\\\s*(?P<header>[^:]+)\\\\s*:(?P<value>.*?)\\\\s*$\\"
-"\")\""
+msgstr "pat = re.compile(r\"\\s*(?P<header>[^:]+)\\s*:(?P<value>.*?)\\s*$\")"
 
 msgid "Feedback"
 msgstr "ਫੀਡਬੈਕ"

howto/sorting.po

@@ -179,19 +179,19 @@ msgid ""
 "[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]"
 msgstr ""
 ">>> class Student:\n"
-"... def __init__(self, name, grade, age):\n"
-"... self.name = name\n"
-"... self.grade = grade\n"
-"... self.age = age\n"
-"... def __repr__(self):\n"
-"... return repr((self.name, self.grade, self.age))\n"
+"...     def __init__(self, name, grade, age):\n"
+"...         self.name = name\n"
+"...         self.grade = grade\n"
+"...         self.age = age\n"
+"...     def __repr__(self):\n"
+"...         return repr((self.name, self.grade, self.age))\n"
 "\n"
 ">>> student_objects = [\n"
-"... Student('john', 'A', 15),\n"
-"... Student('jane', 'B', 12),\n"
-"... Student('dave', 'B', 10),\n"
+"...     Student('john', 'A', 15),\n"
+"...     Student('jane', 'B', 12),\n"
+"...     Student('dave', 'B', 10),\n"
 "... ]\n"
-">>> sorted(student_objects, key=lambda student: student.age) # sort by age\n"
+">>> sorted(student_objects, key=lambda student: student.age)   # sort by age\n"
 "[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]"
 
 msgid ""
@@ -370,7 +370,7 @@ msgid ""
 "This can be abstracted out into a wrapper function that can take a list and "
 "tuples of field and order to sort them on multiple passes."
 msgstr ""
-"ਇਸ ਵਿਚਾਰ ਨੂੰ ਇੱਕ wrapper function ਵਿੱਚ ਬਦਲਿਆ ਜਾ ਸਕਦਾ ਹੈ ਜੋ ਲਿਸਟ ਅਤੇ field तथा order "
+"ਇਸ ਵਿਚਾਰ ਨੂੰ ਇੱਕ wrapper function ਵਿੱਚ ਬਦਲਿਆ ਜਾ ਸਕਦਾ ਹੈ ਜੋ ਲਿਸਟ ਅਤੇ field ਅਤੇ order "
 "ਵਾਲੀਆਂ tuples ਨੂੰ ਸਵੀਕਾਰ ਕਰਕੇ ਕਈ ਪਾਸਾਂ ਵਿੱਚ ਸੋਰਟ ਕਰ ਸਕਦਾ ਹੈ।"
 
 msgid ""
@@ -383,9 +383,9 @@ msgid ""
 "[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]"
 msgstr ""
 ">>> def multisort(xs, specs):\n"
-"... for key, reverse in reversed(specs):\n"
-"... xs.sort(key=attrgetter(key), reverse=reverse)\n"
-"... return xs\n"
+"...     for key, reverse in reversed(specs):\n"
+"...         xs.sort(key=attrgetter(key), reverse=reverse)\n"
+"...     return xs\n"
 "\n"
 ">>> multisort(list(student_objects), (('grade', True), ('age', False)))\n"
 "[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]"
@@ -461,8 +461,9 @@ msgid ""
 "The sort is stable -- if two items have the same key, their order will be "
 "preserved in the sorted list."
 msgstr ""
-"ਸੋਰਟ ਸਥਿਰ ਰਹਿੰਦਾ ਹੈ -- ਜੇ ਦੋ ਆਈਟਮਾਂ ਦੀ key ਇੱਕੋ ਜਿਹੀ ਹੋਵੇ, ਤਾਂ ਉਨ੍ਹਾਂ ਦਾ ਕ੍ਰਮ ਸੋਰਟ ਕੀਤੀ "
-"ਲਿਸਟ ਵਿੱਚ ਬਰਕਰਾਰ ਰਹੇਗਾ।"
+"ਮੂਲ items ਦਾ ਤੁਲਨਾਯੋਗ ਹੋਣਾ ਜ਼ਰੂਰੀ ਨਹੀਂ ਕਿਉਂਕਿ ਸਜਾਈਆਂ ਗਈਆਂ tuples ਦਾ ਕ੍ਰਮ ਵੱਧ ਤੋਂ ਵੱਧ ਪਹਿਲੇ "
+"ਦੋ items ਦੁਆਰਾ ਨਿਰਧਾਰਤ ਕੀਤਾ ਜਾਵੇਗਾ। ਉਦਾਹਰਨ ਲਈ ਮੂਲ ਲਿਸਟ ਵਿੱਚ complex numbers ਹੋ ਸਕਦੇ ਹਨ "
+"ਜਿਨ੍ਹਾਂ ਨੂੰ ਸਿੱਧੇ ਤੌਰ 'ਤੇ ਸੋਰਟ ਨਹੀਂ ਕੀਤਾ ਜਾ ਸਕਦਾ।"
 
 msgid ""
 "The original items do not have to be comparable because the ordering of the "
@@ -533,7 +534,7 @@ msgid "sorted(words, key=cmp_to_key(strcoll))  # locale-aware sort order"
 msgstr "sorted(words, key=cmp_to_key(strcoll)) # locale-aware sort order"
 
 msgid "Strategies For Unorderable Types and Values"
-msgstr "ਅਸੋਰਟਯੋਗ ਕਿਸਮਾਂ ਅਤੇ ਮੁੱਲਾਂ ਲਈ ਰਣਨੀਤੀਆਂ"
+msgstr "Unorderable ਕਿਸਮਾਂ ਅਤੇ ਮੁੱਲਾਂ ਲਈ ਰਣਨੀਤੀਆਂ"
 
 msgid ""
 "A number of type and value issues can arise when sorting. Here are some "

library/fileinput.po

@@ -48,7 +48,7 @@ msgid ""
 msgstr ""
 "import fileinput\n"
 "for line in fileinput.input(encoding=\"utf-8\"):\n"
-"process(line)"
+"    process(line)"
 
 msgid ""
 "This iterates over the lines of all files listed in ``sys.argv[1:]``, "
@@ -136,9 +136,9 @@ msgid ""
 "keyword:`with` statement.  In this example, *input* is closed after the :"
 "keyword:`!with` statement is exited, even if an exception occurs::"
 msgstr ""
-":class:`FileInput` ਇੰਸਟੈਂਸ ਨੂੰ :keyword:`with` ਸਟੇਟਮੈਂਟ ਵਿੱਚ ਇੱਕ ਕਾਂਟੈਕਸਟ ਮੈਨੇਜਰ ਵਜੋਂ ਵਰਤਿਆ "
-"ਜਾ ਸਕਦਾ ਹੈ। ਇਸ ਉਦਾਹਰਨ ਵਿੱਚ, :keyword:`!with` with ਸਟੇਟਮੈਂਟ ਤੋਂ ਬਾਹਰ ਨਿਕਲਣ ਤੋਂ ਬਾਅਦ "
-"*input* ਬੰਦ ਹੋ ਜਾਂਦਾ ਹੈ, ਭਾਵੇਂ ਕੋਈ ਐਕਸੈਪਸ਼ਨ ਆ ਜਾਵੇ:"
+":class:`FileInput` ਇੰਸਟੈਂਸ ਨੂੰ :keyword:`with` ਸਟੇਟਮੈਂਟ ਵਿੱਚ ਇੱਕ context manager ਵਜੋਂ "
+"ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ। ਇਸ ਉਦਾਹਰਨ ਵਿੱਚ, :keyword:`!with` ਸਟੇਟਮੈਂਟ ਤੋਂ ਬਾਹਰ ਨਿਕਲਣ ਤੋਂ ਬਾਅਦ "
+"*input* ਬੰਦ ਹੋ ਜਾਂਦਾ ਹੈ, ਭਾਵੇਂ ਕੋਈ exception ਆ ਜਾਵੇ:"
 
 msgid ""
 "with fileinput.input(files=('spam.txt', 'eggs.txt'), encoding=\"utf-8\") as "