inscriptis 2.4.0.1__tar.gz → 2.5.2__tar.gz

inscriptis-2.5.2/AUTHORS

@@ -0,0 +1,5 @@
+Albert Weichselbraun <albert.weichselbraun@fhgr.ch>
+Fabian Odoni <fabian.odoni@fhgr.ch>
+
+The design of inscriptis has originally been inspired by SpiffWikiMarkup
+developed by Samuel Abels <spam2, debain, org>.

{inscriptis-2.4.0.1 → inscriptis-2.5.2}/PKG-INFO

@@ -1,30 +1,30 @@
 Metadata-Version: 2.1
 Name: inscriptis
-Version: 2.4.0.1
+Version: 2.5.2
 Summary: inscriptis - HTML to text converter.
 Home-page: https://github.com/weblyzard/inscriptis
 License: Apache-2.0
 Keywords: HTML,converter,text
 Author: Albert Weichselbraun
 Author-email: albert.weichselbraun@fhgr.ch
-Requires-Python: >=3.8,<4.0
+Requires-Python: >=3.9,<4.0
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Text Processing
 Classifier: Topic :: Text Processing :: Markup :: HTML
 Classifier: Topic :: Utilities
 Provides-Extra: web-service
-Requires-Dist: fastapi (>=0.109.0,<0.110.0) ; extra == "web-service"
+Requires-Dist: fastapi (>=0.109.1,<0.110.0) ; extra == "web-service"
 Requires-Dist: lxml (>=4.9.3)
-Requires-Dist: requests (>=2.31.0)
-Requires-Dist: uvicorn (>=0.25.0,<0.26.0) ; extra == "web-service"
+Requires-Dist: requests (==2.32.2)
+Requires-Dist: uvicorn (>=0.27.1,<0.28.0) ; extra == "web-service"
 Project-URL: Documentation, https://inscriptis.readthedocs.io/en
 Project-URL: Repository, https://github.com/weblyzard/inscriptis
 Description-Content-Type: text/x-rst
@@ -129,12 +129,6 @@ Or, if you don't have pip installed::
 
     $ easy_install inscriptis
 
-If you want to install from the latest sources, you can do::
-
-    $ git clone https://github.com/weblyzard/inscriptis.git
-    $ cd inscriptis
-    $ python setup.py install
-
 
 Python library
 ==============
@@ -222,7 +216,7 @@ HTML to annotated text conversion
 ---------------------------------
 convert and annotate HTML from a Web page using the provided annotation rules. 
 
-Download the example `annotation-profile.json <https://github.com/weblyzard/inscriptis/blob/master/examples/annotation-profile.json>`_ and save it to your working directory::
+Download the example `annotation-profile.json <https://github.com/weblyzard/inscriptis/blob/master/examples/annotation/annotation-profile.json>`_ and save it to your working directory::
 
   $ inscript https://www.fhgr.ch -r annotation-profile.json
 
@@ -273,7 +267,7 @@ that are suitable for your particular application. Post processors can be
 specified with the ``-p`` or ``--postprocessor`` command line argument::
 
   $ inscript https://www.fhgr.ch \
-          -r ./examples/annotation-profile.json \
+          -r ./annotation/examples/annotation-profile.json \
           -p surface
 
 
@@ -511,7 +505,8 @@ be used within a program:
 .. code-block:: python
 
   import urllib.request
-  from inscriptis import get_annotated_text, ParserConfig
+  from inscriptis import get_annotated_text
+  from inscriptis.model.config import ParserConfig
 
   url = "https://www.fhgr.ch"
   html = urllib.request.urlopen(url).read().decode('utf-8')
@@ -570,15 +565,24 @@ If the fine-tuning options discussed above are not sufficient, you may even over
 
 .. code-block:: python
 
-    inscriptis = Inscriptis(html, config)
+    from inscriptis import ParserConfig
+    from inscriptis.html_engine import Inscriptis
+    from inscriptis.model.tag import CustomHtmlTagHandlerMapping
 
-    inscriptis.start_tag_handler_dict['a'] = my_handle_start_a
-    inscriptis.end_tag_handler_dict['a'] = my_handle_end_a
+    my_mapping = CustomHtmlTagHandlerMapping(
+        start_tag_mapping={'a': my_handle_start_a},
+        end_tag_mapping={'a': my_handle_end_a}
+    )
+    inscriptis = Inscriptis(html_tree, 
+                            ParserConfig(custom_html_tag_handler_mapping=my_mapping))
     text = inscriptis.get_text()
 		
 
 In the example the standard HTML handlers for the ``a`` tag are overwritten with custom versions (i.e., ``my_handle_start_a`` and ``my_handle_end_a``).
-You may define custom handlers for any tag, regardless of whether it already exists in ``start_tag_handler_dict`` or ``end_tag_handler_dict``. 
+You may define custom handlers for any tag, regardless of whether it already exists in the standard mapping.
+
+Please refer to `custom-html-handling.py <https://github.com/weblyzard/inscriptis/blob/master/examples/custom-html-handling.py>`_ for a working example. 
+The standard HTML tag handlers can be found in the `inscriptis.model.tag <https://github.com/weblyzard/inscriptis/blob/master/src/inscriptis/model/tag>`_ package.
 
 Optimizing memory consumption
 -----------------------------

{inscriptis-2.4.0.1 → inscriptis-2.5.2}/README.rst

@@ -98,12 +98,6 @@ Or, if you don't have pip installed::
 
     $ easy_install inscriptis
 
-If you want to install from the latest sources, you can do::
-
-    $ git clone https://github.com/weblyzard/inscriptis.git
-    $ cd inscriptis
-    $ python setup.py install
-
 
 Python library
 ==============
@@ -191,7 +185,7 @@ HTML to annotated text conversion
 ---------------------------------
 convert and annotate HTML from a Web page using the provided annotation rules. 
 
-Download the example `annotation-profile.json <https://github.com/weblyzard/inscriptis/blob/master/examples/annotation-profile.json>`_ and save it to your working directory::
+Download the example `annotation-profile.json <https://github.com/weblyzard/inscriptis/blob/master/examples/annotation/annotation-profile.json>`_ and save it to your working directory::
 
   $ inscript https://www.fhgr.ch -r annotation-profile.json
 
@@ -242,7 +236,7 @@ that are suitable for your particular application. Post processors can be
 specified with the ``-p`` or ``--postprocessor`` command line argument::
 
   $ inscript https://www.fhgr.ch \
-          -r ./examples/annotation-profile.json \
+          -r ./annotation/examples/annotation-profile.json \
           -p surface
 
 
@@ -480,7 +474,8 @@ be used within a program:
 .. code-block:: python
 
   import urllib.request
-  from inscriptis import get_annotated_text, ParserConfig
+  from inscriptis import get_annotated_text
+  from inscriptis.model.config import ParserConfig
 
   url = "https://www.fhgr.ch"
   html = urllib.request.urlopen(url).read().decode('utf-8')
@@ -539,15 +534,24 @@ If the fine-tuning options discussed above are not sufficient, you may even over
 
 .. code-block:: python
 
-    inscriptis = Inscriptis(html, config)
+    from inscriptis import ParserConfig
+    from inscriptis.html_engine import Inscriptis
+    from inscriptis.model.tag import CustomHtmlTagHandlerMapping
 
-    inscriptis.start_tag_handler_dict['a'] = my_handle_start_a
-    inscriptis.end_tag_handler_dict['a'] = my_handle_end_a
+    my_mapping = CustomHtmlTagHandlerMapping(
+        start_tag_mapping={'a': my_handle_start_a},
+        end_tag_mapping={'a': my_handle_end_a}
+    )
+    inscriptis = Inscriptis(html_tree, 
+                            ParserConfig(custom_html_tag_handler_mapping=my_mapping))
     text = inscriptis.get_text()
 		
 
 In the example the standard HTML handlers for the ``a`` tag are overwritten with custom versions (i.e., ``my_handle_start_a`` and ``my_handle_end_a``).
-You may define custom handlers for any tag, regardless of whether it already exists in ``start_tag_handler_dict`` or ``end_tag_handler_dict``. 
+You may define custom handlers for any tag, regardless of whether it already exists in the standard mapping.
+
+Please refer to `custom-html-handling.py <https://github.com/weblyzard/inscriptis/blob/master/examples/custom-html-handling.py>`_ for a working example. 
+The standard HTML tag handlers can be found in the `inscriptis.model.tag <https://github.com/weblyzard/inscriptis/blob/master/src/inscriptis/model/tag>`_ package.
 
 Optimizing memory consumption
 -----------------------------

{inscriptis-2.4.0.1 → inscriptis-2.5.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "inscriptis"
-version = "2.4.0.1"
+version = "2.5.2"
 authors = ["Albert Weichselbraun <albert.weichselbraun@fhgr.ch>", "Fabian Odoni <fabian.odoni@fhgr.ch>"]
 description = "inscriptis - HTML to text converter."
 keywords = ["HTML", "converter", "text"]
@@ -12,11 +12,11 @@ classifiers = [
         'Topic :: Text Processing :: Markup :: HTML',
         'Topic :: Utilities',
         'Programming Language :: Python :: 3',
-        'Programming Language :: Python :: 3.8',
         'Programming Language :: Python :: 3.9',
         'Programming Language :: Python :: 3.10',
         'Programming Language :: Python :: 3.11',
         'Programming Language :: Python :: 3.12',
+        'Programming Language :: Python :: 3.13',
     ]
 homepage = "https://github.com/weblyzard/inscriptis"
 repository = "https://github.com/weblyzard/inscriptis"
@@ -39,13 +39,13 @@ web-service = ["fastapi", "uvicorn"]
 
 
 [tool.poetry.dependencies]
-python = "^3.8 || ^3.9 || ^3.10 || ^3.11 || ^3.12"
-requests = ">=2.31.0"
+python = "^3.9 || ^3.10 || ^3.11 || ^3.12 || ^3.13"
+requests = "2.32.2"
 lxml = ">=4.9.3"
 
 # optional dependencies
-fastapi = { version = "^0.109.0", optional = true }
-uvicorn = { version = "^0.25.0", optional = true }
+fastapi = { version = "^0.109.1", optional = true }
+uvicorn = { version = "^0.27.1", optional = true }
 
 
 [build-system]
@@ -56,8 +56,8 @@ build-backend = "poetry.core.masonry.api"
 # code formatting with black
 [tool.black]
 line-length = 88
-target-version = ["py38", "py39", "py310", "py311", "py312"]
+target-version = ["py39", "py310", "py311", "py312", "py313"]
 extend-exclude = '\.html$|\.json$|\.txt$|/a$|/b$'
 include = '''
-  ^/src/|^/tests/|^/benchmarking/
+  ^/src/|^/tests/|^/benchmarking/|^/examples/
 '''

{inscriptis-2.4.0.1 → inscriptis-2.5.2}/src/inscriptis/__init__.py

@@ -60,12 +60,12 @@ Annotations in the `label` field are returned as a list of triples with
 """
 
 import re
-from lxml.html import fromstring, HtmlElement
-from lxml.etree import ParserError
-
 from typing import Dict, Optional, Any
-
 from inscriptis.model.config import ParserConfig
+
+from lxml.etree import ParserError
+from lxml.html import fromstring, HtmlElement
+
 from inscriptis.html_engine import Inscriptis
 
 RE_STRIP_XML_DECLARATION = re.compile(r"^<\?xml [^>]+?\?>")
@@ -132,5 +132,6 @@ def get_annotated_text(
         return {}
 
     inscriptis = Inscriptis(html_tree, config)
+    text = inscriptis.get_text()
     labels = [(a.start, a.end, a.metadata) for a in inscriptis.get_annotations()]
-    return {"text": inscriptis.get_text(), "label": labels}
+    return {"text": text, "label": labels}

{inscriptis-2.4.0.1 → inscriptis-2.5.2}/src/inscriptis/annotation/__init__.py

@@ -1,7 +1,7 @@
 """The model used for saving annotations."""
 
-from typing import NamedTuple, Tuple
 from typing import List
+from typing import NamedTuple
 
 from inscriptis.html_properties import HorizontalAlignment
 
@@ -25,8 +25,8 @@ class Annotation(NamedTuple):
     """the annotation's start index within the text output."""
     end: int
     """the annotation's end index within the text output."""
-    metadata: Tuple[str]
-    """a tuple of tags to be attached to the annotation."""
+    metadata: str
+    """the tag to be attached to the annotation."""
 
 
 def horizontal_shift(

{inscriptis-2.4.0.1 → inscriptis-2.5.2}/src/inscriptis/annotation/parser.py

@@ -18,6 +18,7 @@ Example::
 """
 from collections import defaultdict
 from copy import copy
+from typing import Dict, Tuple, List
 
 from inscriptis.model.html_element import HtmlElement, DEFAULT_HTML_ELEMENT
 
@@ -85,7 +86,7 @@ class AnnotationModel:
         self.css = css_profile
 
     @staticmethod
-    def _parse(model: dict) -> "AnnotationModel":
+    def _parse(model: dict) -> Tuple[Dict, List]:
         """Compute the AnnotationModel from a model dictionary.
 
         Returns:

{inscriptis-2.4.0.1 → inscriptis-2.5.2}/src/inscriptis/cli/inscript.py

@@ -5,14 +5,14 @@
 import argparse
 import sys
 from json import load, dumps
-from typing import Optional
 from pathlib import Path
+from typing import Optional
 
 import requests
 
 from inscriptis import get_text, get_annotated_text
-from inscriptis.metadata import __version__, __copyright__, __license__
 from inscriptis.css_profiles import CSS_PROFILES
+from inscriptis.metadata import __version__, __copyright__, __license__
 from inscriptis.model.config import ParserConfig
 
 DEFAULT_ENCODING = "utf8"
@@ -148,6 +148,7 @@ def get_html_content(url: str, timeout: int, encoding: str = None) -> Optional[s
     Args:
         url: URL to the HTML content, or None if the content is obtained from stdin.
         encoding: used encoding.
+        timeout: timeout in seconds for retrieving the URL.
 
     Returns:
         The html_content or None, if no content could be extracted.
@@ -155,17 +156,15 @@ def get_html_content(url: str, timeout: int, encoding: str = None) -> Optional[s
     """
     if not url:
         return sys.stdin.read()
-    elif Path(url).is_file():
-        with Path(url).open(
-            encoding=encoding or DEFAULT_ENCODING, errors="ignore"
-        ) as f:
+    elif (p := Path(url)).is_file():
+        with p.open(encoding=encoding or DEFAULT_ENCODING, errors="ignore") as f:
             return f.read()
     elif url.startswith("http://") or url.startswith("https://"):
         req = requests.get(url, timeout=timeout)
         return req.content.decode(encoding or req.encoding)
 
 
-def cli():
+def cli() -> None:
     """Run the inscript command line client."""
     args = parse_command_line()
     if not (html_content := get_html_content(args.input, args.timeout, args.encoding)):

inscriptis-2.5.2/src/inscriptis/html_engine.py

@@ -0,0 +1,132 @@
+#!/usr/bin/env python
+# coding:utf-8
+"""The HTML Engine is responsible for converting HTML to text."""
+from typing import List, Dict, Callable
+
+import lxml.html
+from lxml.etree import Comment
+
+from inscriptis.annotation import Annotation
+from inscriptis.model.canvas import Canvas
+from inscriptis.model.config import ParserConfig
+from inscriptis.model.html_document_state import HtmlDocumentState
+from inscriptis.model.tag.a_tag import a_start_handler, a_end_handler
+from inscriptis.model.tag.br_tag import br_start_handler
+from inscriptis.model.tag.img_tag import img_start_handler
+from inscriptis.model.tag.list_tag import (
+    ul_start_handler,
+    ol_start_handler,
+    li_start_handler,
+    ul_end_handler,
+    ol_end_handler,
+)
+from inscriptis.model.tag.table_tag import (
+    table_start_handler,
+    tr_start_handler,
+    td_start_handler,
+    table_end_handler,
+    td_end_handler,
+)
+
+
+class Inscriptis:
+    """Translate an lxml HTML tree to the corresponding text representation.
+
+    Args:
+      html_tree: the lxml HTML tree to convert.
+      config: an optional ParserConfig configuration object.
+
+    Example::
+
+      from lxml.html import fromstring
+      from inscriptis.html_engine import Inscriptis
+
+      html_content = "<html><body><h1>Test</h1></body></html>"
+
+      # create an HTML tree from the HTML content.
+      html_tree = fromstring(html_content)
+
+      # transform the HTML tree to text.
+      parser = Inscriptis(html_tree)
+      text = parser.get_text()
+    """
+
+    def __init__(self, html_tree: lxml.html.HtmlElement, config: ParserConfig = None):
+        # use the default configuration, if no config object is provided
+        config = config or ParserConfig()
+
+        # setup start and end tag call tables
+        self.start_tag_handler_dict: Dict[
+            str, Callable[[HtmlDocumentState, Dict], None]
+        ] = {
+            "table": table_start_handler,
+            "tr": tr_start_handler,
+            "td": td_start_handler,
+            "th": td_start_handler,
+            "ul": ul_start_handler,
+            "ol": ol_start_handler,
+            "li": li_start_handler,
+            "br": br_start_handler,
+            "a": a_start_handler if config.parse_a() else None,
+            "img": img_start_handler if config.display_images else None,
+        }
+        self.end_tag_handler_dict: Dict[str, Callable[[HtmlDocumentState], None]] = {
+            "table": table_end_handler,
+            "ul": ul_end_handler,
+            "ol": ol_end_handler,
+            "td": td_end_handler,
+            "th": td_end_handler,
+            "a": a_end_handler if config.parse_a() else None,
+        }
+
+        if config.custom_html_tag_handler_mapping:
+            self.start_tag_handler_dict.update(
+                config.custom_html_tag_handler_mapping.start_tag_mapping
+            )
+            self.end_tag_handler_dict.update(
+                config.custom_html_tag_handler_mapping.end_tag_mapping
+            )
+
+        # parse the HTML tree
+        self.canvas = self._parse_html_tree(HtmlDocumentState(config), html_tree)
+
+    def _parse_html_tree(self, state: HtmlDocumentState, tree) -> Canvas:
+        """Parse the HTML tree.
+
+        Args:
+            tree: the HTML tree to parse.
+        """
+        if isinstance(tree.tag, str):
+            state.apply_starttag_layout(tree.tag, tree.attrib)
+
+            if handler := self.start_tag_handler_dict.get(tree.tag):
+                handler(state, tree.attrib)
+            cur = state.tags[-1]
+            cur.canvas.open_tag(cur)
+
+            state.tags[-1].write(tree.text)
+
+            for node in tree:
+                self._parse_html_tree(state, node)
+
+            # handle the endtag
+            if handler := self.end_tag_handler_dict.get(tree.tag):
+                handler(state)
+            prev = state.tags.pop()
+            prev.canvas.close_tag(prev)
+
+            # write the tail text to the element's container
+            state.tags[-1].write(tree.tail)
+
+        elif tree.tag is Comment and tree.tail:
+            state.tags[-1].canvas.write(state.tags[-1], tree.tail)
+
+        return state.canvas
+
+    def get_text(self) -> str:
+        """Return the text extracted from the HTML page."""
+        return self.canvas.get_text()
+
+    def get_annotations(self) -> List[Annotation]:
+        """Return the annotations extracted from the HTML page."""
+        return self.canvas.annotations

{inscriptis-2.4.0.1 → inscriptis-2.5.2}/src/inscriptis/html_properties.py

@@ -4,7 +4,7 @@ Supported attributes::
  1. :class:`Display` properties.
  2. :class:`WhiteSpace` properties.
  3. :class:`HorizontalAlignment` properties.
- 4. :class:`VerticalAlignment` properites.
+ 4. :class:`VerticalAlignment` properties.
 """
 
 from enum import Enum

{inscriptis-2.4.0.1 → inscriptis-2.5.2}/src/inscriptis/metadata.py

@@ -8,7 +8,7 @@ __author__ = "Albert Weichselbraun, Fabian Odoni"
 __author_email__ = "albert.weichselbraun@fhgr.ch, fabian.odoni@fhgr.ch"
 __copyright__ = (
     f"{metadata.metadata(PACKAGE)['Name']} "
-    + f"{metadata.metadata(PACKAGE)['Version']} © 2016-2023 {__author__}"
+    + f"{metadata.metadata(PACKAGE)['Version']} © 2016-2025 {__author__}"
 )
 __license__ = metadata.metadata(PACKAGE)["License"]
 __version__ = metadata.metadata(PACKAGE)["Version"]

{inscriptis-2.4.0.1 → inscriptis-2.5.2}/src/inscriptis/model/attribute.py

@@ -57,16 +57,12 @@ class Attribute:
             attributes: the list of attributes
             html_element: the HTML element for which the attributes are parsed
         """
-        supported_attributes = (
-            (name, val)
-            for name, val in attributes.items()
-            if name in self.attribute_mapping
-        )
-        for attr_name, attr_value in supported_attributes:
-            self.attribute_mapping[attr_name](attr_value, html_element)
+        for attr_name, attr_value in attributes.items():
+            if attr_name in self.attribute_mapping:
+                self.attribute_mapping[attr_name](attr_value, html_element)
         return html_element
 
-    def merge_attribute_map(self, annotations: List[ApplyAnnotation] = None):
+    def merge_attribute_map(self, annotations: List[ApplyAnnotation] = None) -> None:
         attributes = copy(self.attribute_mapping)
         for a in annotations:
             attributes[a.attr] = (

{inscriptis-2.4.0.1 → inscriptis-2.5.2}/src/inscriptis/model/canvas/__init__.py

@@ -17,8 +17,8 @@ textual content to the canvas which is managed by the following three classes:
 from inscriptis.annotation import Annotation
 from inscriptis.html_properties import WhiteSpace, Display
 from inscriptis.model.canvas.block import Block
-from inscriptis.model.html_element import HtmlElement
 from inscriptis.model.canvas.prefix import Prefix
+from inscriptis.model.html_element import HtmlElement
 
 
 class Canvas:
@@ -64,10 +64,10 @@ class Canvas:
         if tag.display == Display.block:
             self.open_block(tag)
 
-    def open_block(self, tag: HtmlElement):
+    def open_block(self, tag: HtmlElement) -> None:
         """Open an HTML block element."""
         # write missing bullets, if no content has been written
-        if not self._flush_inline() and tag.list_bullet:
+        if not self.flush_inline() and tag.list_bullet:
             self.write_unconsumed_bullet()
         self.current_block.prefix.register_prefix(tag.padding_inline, tag.list_bullet)
 
@@ -79,7 +79,7 @@ class Canvas:
             self.blocks.append("\n" * (required_newlines - 1))
             self.margin = required_margin
 
-    def write_unconsumed_bullet(self):
+    def write_unconsumed_bullet(self) -> None:
         """Write unconsumed bullets to the blocks list."""
         bullet = self.current_block.prefix.unconsumed_bullet
         if bullet:
@@ -100,7 +100,7 @@ class Canvas:
         """
         if tag.display == Display.block:
             # write missing bullets, if no content has been written so far.
-            if not self._flush_inline() and tag.list_bullet:
+            if not self.flush_inline() and tag.list_bullet:
                 self.write_unconsumed_bullet()
             self.current_block.prefix.remove_last_prefix()
             self.close_block(tag)
@@ -116,7 +116,7 @@ class Canvas:
                     Annotation(start_idx, self.current_block.idx, annotation)
                 )
 
-    def close_block(self, tag: HtmlElement):
+    def close_block(self, tag: HtmlElement) -> None:
         """Close the given HtmlElement by writing its bottom margin.
 
         Args:
@@ -128,17 +128,17 @@ class Canvas:
             self.blocks.append("\n" * (required_newlines - 1))
             self.margin = tag.margin_after
 
-    def write_newline(self):
-        if not self._flush_inline():
+    def write_newline(self) -> None:
+        if not self.flush_inline():
             self.blocks.append("")
             self.current_block = self.current_block.new_block()
 
     def get_text(self) -> str:
         """Provide a text representation of the Canvas."""
-        self._flush_inline()
+        self.flush_inline()
         return "\n".join(self.blocks)
 
-    def _flush_inline(self) -> bool:
+    def flush_inline(self) -> bool:
         """Attempt to flush the content in self.current_block into a new block.
 
         Notes:

{inscriptis-2.4.0.1 → inscriptis-2.5.2}/src/inscriptis/model/canvas/block.py

@@ -1,7 +1,14 @@
 """Representation of a text block within the HTML canvas."""
+from __future__ import annotations
+
 from html import unescape
+from typing import TYPE_CHECKING
+
 from inscriptis.html_properties import WhiteSpace
 
+if TYPE_CHECKING:
+    from inscriptis.model.canvas import Prefix
+
 
 class Block:
     """The current block of text.
@@ -19,7 +26,7 @@ class Block:
 
     __slots__ = ("idx", "prefix", "_content", "collapsable_whitespace")
 
-    def __init__(self, idx: int, prefix: str):
+    def __init__(self, idx: int, prefix: Prefix):
         self.idx = idx
         self.prefix = prefix
         self._content = ""

{inscriptis-2.4.0.1 → inscriptis-2.5.2}/src/inscriptis/model/canvas/prefix.py

@@ -22,7 +22,7 @@ class Prefix:
         self.bullets = []
         self.consumed = False
 
-    def register_prefix(self, padding_inline, bullet):
+    def register_prefix(self, padding_inline: int, bullet: str) -> None:
         """Register the given prefix.
 
         Args:
@@ -33,13 +33,13 @@ class Prefix:
         self.paddings.append(padding_inline)
         self.bullets.append(bullet if bullet else "")
 
-    def remove_last_prefix(self):
+    def remove_last_prefix(self) -> None:
         """Remove the last prefix from the list."""
         with suppress(IndexError):
             self.current_padding -= self.paddings.pop()
             del self.bullets[-1]
 
-    def pop_next_bullet(self):
+    def pop_next_bullet(self) -> str:
         """Pop the next bullet to use, if any bullet is available."""
         next_bullet_idx = (
             next((-idx for idx, val in enumerate(reversed(self.bullets)) if val), 1) - 1
@@ -53,7 +53,7 @@ class Prefix:
         return bullet
 
     @property
-    def first(self):
+    def first(self) -> str:
         """Return the prefix used at the beginning of a tag.
 
         Note::
@@ -69,7 +69,7 @@ class Prefix:
         return " " * (self.current_padding - len(bullet)) + bullet
 
     @property
-    def unconsumed_bullet(self):
+    def unconsumed_bullet(self) -> str:
         """Yield any yet unconsumed bullet.
 
         Note::
@@ -87,7 +87,7 @@ class Prefix:
         return " " * (padding - len(bullet)) + bullet
 
     @property
-    def rest(self):
+    def rest(self) -> str:
         """Return the prefix used for new lines within a block.
 
         This prefix is used for pre-text that contains newlines. The lines