library/html.parser.po

# 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>, YEAR.
#
# Translators:
# Rafael Fontenelle <rffontenelle@gmail.com>, 2025
#
#, fuzzy
msgid ""
msgstr ""
"Project-Id-Version: Python 3.13\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2025-05-08 03:57+0000\n"
"PO-Revision-Date: 2025-05-08 05:09+0000\n"
"Last-Translator: Rafael Fontenelle <rffontenelle@gmail.com>, 2025\n"
"Language-Team: Polish (https://app.transifex.com/python-doc/teams/5390/pl/)\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Language: pl\n"
"Plural-Forms: nplurals=4; plural=(n==1 ? 0 : (n%10>=2 && n%10<=4) && "
"(n%100<12 || n%100>14) ? 1 : n!=1 && (n%10>=0 && n%10<=1) || (n%10>=5 && "
"n%10<=9) || (n%100>=12 && n%100<=14) ? 2 : 3);\n"

msgid ":mod:`!html.parser` --- Simple HTML and XHTML parser"
msgstr ""

msgid "**Source code:** :source:`Lib/html/parser.py`"
msgstr ""

msgid ""
"This module defines a class :class:`HTMLParser` which serves as the basis "
"for parsing text files formatted in HTML (HyperText Mark-up Language) and "
"XHTML."
msgstr ""

msgid "Create a parser instance able to parse invalid markup."
msgstr ""

msgid ""
"If *convert_charrefs* is ``True`` (the default), all character references "
"(except the ones in ``script``/``style`` elements) are automatically "
"converted to the corresponding Unicode characters."
msgstr ""

msgid ""
"An :class:`.HTMLParser` instance is fed HTML data and calls handler methods "
"when start tags, end tags, text, comments, and other markup elements are "
"encountered.  The user should subclass :class:`.HTMLParser` and override its "
"methods to implement the desired behavior."
msgstr ""

msgid ""
"This parser does not check that end tags match start tags or call the end-"
"tag handler for elements which are closed implicitly by closing an outer "
"element."
msgstr ""

msgid "*convert_charrefs* keyword argument added."
msgstr ""

msgid "The default value for argument *convert_charrefs* is now ``True``."
msgstr ""

msgid "Example HTML Parser Application"
msgstr ""

msgid ""
"As a basic example, below is a simple HTML parser that uses the :class:"
"`HTMLParser` class to print out start tags, end tags, and data as they are "
"encountered:"
msgstr ""

msgid ""
"from html.parser import HTMLParser\n"
"\n"
"class MyHTMLParser(HTMLParser):\n"
"    def handle_starttag(self, tag, attrs):\n"
"        print(\"Encountered a start tag:\", tag)\n"
"\n"
"    def handle_endtag(self, tag):\n"
"        print(\"Encountered an end tag :\", tag)\n"
"\n"
"    def handle_data(self, data):\n"
"        print(\"Encountered some data  :\", data)\n"
"\n"
"parser = MyHTMLParser()\n"
"parser.feed('<html><head><title>Test</title></head>'\n"
"            '<body><h1>Parse me!</h1></body></html>')"
msgstr ""

msgid "The output will then be:"
msgstr ""

msgid ""
"Encountered a start tag: html\n"
"Encountered a start tag: head\n"
"Encountered a start tag: title\n"
"Encountered some data  : Test\n"
"Encountered an end tag : title\n"
"Encountered an end tag : head\n"
"Encountered a start tag: body\n"
"Encountered a start tag: h1\n"
"Encountered some data  : Parse me!\n"
"Encountered an end tag : h1\n"
"Encountered an end tag : body\n"
"Encountered an end tag : html"
msgstr ""

msgid ":class:`.HTMLParser` Methods"
msgstr ""

msgid ":class:`HTMLParser` instances have the following methods:"
msgstr ""

msgid ""
"Feed some text to the parser.  It is processed insofar as it consists of "
"complete elements; incomplete data is buffered until more data is fed or :"
"meth:`close` is called.  *data* must be :class:`str`."
msgstr ""

msgid ""
"Force processing of all buffered data as if it were followed by an end-of-"
"file mark.  This method may be redefined by a derived class to define "
"additional processing at the end of the input, but the redefined version "
"should always call the :class:`HTMLParser` base class method :meth:`close`."
msgstr ""

msgid ""
"Reset the instance.  Loses all unprocessed data.  This is called implicitly "
"at instantiation time."
msgstr ""

msgid "Return current line number and offset."
msgstr ""

msgid ""
"Return the text of the most recently opened start tag.  This should not "
"normally be needed for structured processing, but may be useful in dealing "
"with HTML \"as deployed\" or for re-generating input with minimal changes "
"(whitespace between attributes can be preserved, etc.)."
msgstr ""

msgid ""
"The following methods are called when data or markup elements are "
"encountered and they are meant to be overridden in a subclass.  The base "
"class implementations do nothing (except for :meth:`~HTMLParser."
"handle_startendtag`):"
msgstr ""

msgid ""
"This method is called to handle the start tag of an element (e.g. ``<div "
"id=\"main\">``)."
msgstr ""

msgid ""
"The *tag* argument is the name of the tag converted to lower case. The "
"*attrs* argument is a list of ``(name, value)`` pairs containing the "
"attributes found inside the tag's ``<>`` brackets.  The *name* will be "
"translated to lower case, and quotes in the *value* have been removed, and "
"character and entity references have been replaced."
msgstr ""

msgid ""
"For instance, for the tag ``<A HREF=\"https://www.cwi.nl/\">``, this method "
"would be called as ``handle_starttag('a', [('href', 'https://www.cwi."
"nl/')])``."
msgstr ""

msgid ""
"All entity references from :mod:`html.entities` are replaced in the "
"attribute values."
msgstr ""

msgid ""
"This method is called to handle the end tag of an element (e.g. ``</div>``)."
msgstr ""

msgid "The *tag* argument is the name of the tag converted to lower case."
msgstr ""

msgid ""
"Similar to :meth:`handle_starttag`, but called when the parser encounters an "
"XHTML-style empty tag (``<img ... />``).  This method may be overridden by "
"subclasses which require this particular lexical information; the default "
"implementation simply calls :meth:`handle_starttag` and :meth:"
"`handle_endtag`."
msgstr ""

msgid ""
"This method is called to process arbitrary data (e.g. text nodes and the "
"content of ``<script>...</script>`` and ``<style>...</style>``)."
msgstr ""

msgid ""
"This method is called to process a named character reference of the form "
"``&name;`` (e.g. ``&gt;``), where *name* is a general entity reference (e.g. "
"``'gt'``).  This method is never called if *convert_charrefs* is ``True``."
msgstr ""

msgid ""
"This method is called to process decimal and hexadecimal numeric character "
"references of the form :samp:`&#{NNN};` and :samp:`&#x{NNN};`.  For example, "
"the decimal equivalent for ``&gt;`` is ``&#62;``, whereas the hexadecimal is "
"``&#x3E;``; in this case the method will receive ``'62'`` or ``'x3E'``.  "
"This method is never called if *convert_charrefs* is ``True``."
msgstr ""

msgid ""
"This method is called when a comment is encountered (e.g. ``<!--comment--"
">``)."
msgstr ""

msgid ""
"For example, the comment ``<!-- comment -->`` will cause this method to be "
"called with the argument ``' comment '``."
msgstr ""

msgid ""
"The content of Internet Explorer conditional comments (condcoms) will also "
"be sent to this method, so, for ``<!--[if IE 9]>IE9-specific content<!"
"[endif]-->``, this method will receive ``'[if IE 9]>IE9-specific content<!"
"[endif]'``."
msgstr ""

msgid ""
"This method is called to handle an HTML doctype declaration (e.g. ``<!"
"DOCTYPE html>``)."
msgstr ""

msgid ""
"The *decl* parameter will be the entire contents of the declaration inside "
"the ``<!...>`` markup (e.g. ``'DOCTYPE html'``)."
msgstr ""

msgid ""
"Method called when a processing instruction is encountered.  The *data* "
"parameter will contain the entire processing instruction. For example, for "
"the processing instruction ``<?proc color='red'>``, this method would be "
"called as ``handle_pi(\"proc color='red'\")``.  It is intended to be "
"overridden by a derived class; the base class implementation does nothing."
msgstr ""

msgid ""
"The :class:`HTMLParser` class uses the SGML syntactic rules for processing "
"instructions.  An XHTML processing instruction using the trailing ``'?'`` "
"will cause the ``'?'`` to be included in *data*."
msgstr ""

msgid ""
"This method is called when an unrecognized declaration is read by the parser."
msgstr ""

msgid ""
"The *data* parameter will be the entire contents of the declaration inside "
"the ``<![...]>`` markup.  It is sometimes useful to be overridden by a "
"derived class.  The base class implementation does nothing."
msgstr ""

msgid "Examples"
msgstr "Przykłady"

msgid ""
"The following class implements a parser that will be used to illustrate more "
"examples:"
msgstr ""

msgid ""
"from html.parser import HTMLParser\n"
"from html.entities import name2codepoint\n"
"\n"
"class MyHTMLParser(HTMLParser):\n"
"    def handle_starttag(self, tag, attrs):\n"
"        print(\"Start tag:\", tag)\n"
"        for attr in attrs:\n"
"            print(\"     attr:\", attr)\n"
"\n"
"    def handle_endtag(self, tag):\n"
"        print(\"End tag  :\", tag)\n"
"\n"
"    def handle_data(self, data):\n"
"        print(\"Data     :\", data)\n"
"\n"
"    def handle_comment(self, data):\n"
"        print(\"Comment  :\", data)\n"
"\n"
"    def handle_entityref(self, name):\n"
"        c = chr(name2codepoint[name])\n"
"        print(\"Named ent:\", c)\n"
"\n"
"    def handle_charref(self, name):\n"
"        if name.startswith('x'):\n"
"            c = chr(int(name[1:], 16))\n"
"        else:\n"
"            c = chr(int(name))\n"
"        print(\"Num ent  :\", c)\n"
"\n"
"    def handle_decl(self, data):\n"
"        print(\"Decl     :\", data)\n"
"\n"
"parser = MyHTMLParser()"
msgstr ""

msgid "Parsing a doctype:"
msgstr ""

msgid ""
">>> parser.feed('<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.01//EN\" '\n"
"...             '\"http://www.w3.org/TR/html4/strict.dtd\">')\n"
"Decl     : DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.01//EN\" \"http://www.w3."
"org/TR/html4/strict.dtd\""
msgstr ""

msgid "Parsing an element with a few attributes and a title:"
msgstr ""

msgid ""
">>> parser.feed('<img src=\"python-logo.png\" alt=\"The Python logo\">')\n"
"Start tag: img\n"
"     attr: ('src', 'python-logo.png')\n"
"     attr: ('alt', 'The Python logo')\n"
">>>\n"
">>> parser.feed('<h1>Python</h1>')\n"
"Start tag: h1\n"
"Data     : Python\n"
"End tag  : h1"
msgstr ""

msgid ""
"The content of ``script`` and ``style`` elements is returned as is, without "
"further parsing:"
msgstr ""

msgid ""
">>> parser.feed('<style type=\"text/css\">#python { color: green }</"
"style>')\n"
"Start tag: style\n"
"     attr: ('type', 'text/css')\n"
"Data     : #python { color: green }\n"
"End tag  : style\n"
"\n"
">>> parser.feed('<script type=\"text/javascript\">'\n"
"...             'alert(\"<strong>hello!</strong>\");</script>')\n"
"Start tag: script\n"
"     attr: ('type', 'text/javascript')\n"
"Data     : alert(\"<strong>hello!</strong>\");\n"
"End tag  : script"
msgstr ""

msgid "Parsing comments:"
msgstr ""

msgid ""
">>> parser.feed('<!--a comment-->'\n"
"...             '<!--[if IE 9]>IE-specific content<![endif]-->')\n"
"Comment  : a comment\n"
"Comment  : [if IE 9]>IE-specific content<![endif]"
msgstr ""

msgid ""
"Parsing named and numeric character references and converting them to the "
"correct char (note: these 3 references are all equivalent to ``'>'``):"
msgstr ""

msgid ""
">>> parser = MyHTMLParser()\n"
">>> parser.feed('&gt;&#62;&#x3E;')\n"
"Data     : >>>\n"
"\n"
">>> parser = MyHTMLParser(convert_charrefs=False)\n"
">>> parser.feed('&gt;&#62;&#x3E;')\n"
"Named ent: >\n"
"Num ent  : >\n"
"Num ent  : >"
msgstr ""

msgid ""
"Feeding incomplete chunks to :meth:`~HTMLParser.feed` works, but :meth:"
"`~HTMLParser.handle_data` might be called more than once (unless "
"*convert_charrefs* is set to ``True``):"
msgstr ""

msgid ""
">>> for chunk in ['<sp', 'an>buff', 'ered', ' text</s', 'pan>']:\n"
"...     parser.feed(chunk)\n"
"...\n"
"Start tag: span\n"
"Data     : buff\n"
"Data     : ered\n"
"Data     :  text\n"
"End tag  : span"
msgstr ""

msgid "Parsing invalid HTML (e.g. unquoted attributes) also works:"
msgstr ""

msgid ""
">>> parser.feed('<p><a class=link href=#main>tag soup</p ></a>')\n"
"Start tag: p\n"
"Start tag: a\n"
"     attr: ('class', 'link')\n"
"     attr: ('href', '#main')\n"
"Data     : tag soup\n"
"End tag  : p\n"
"End tag  : a"
msgstr ""

msgid "HTML"
msgstr "HTML"

msgid "XHTML"
msgstr ""