resion 22.0.1__tar.gz

resion-22.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 resion
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

resion-22.0.1/PKG-INFO

@@ -0,0 +1,75 @@
+Metadata-Version: 2.4
+Name: resion
+Version: 22.0.1
+Summary: Minimal tree-based HTML parsing with basic selectors.
+Author-email: hositel <hositel@gmail.com>
+License-Expression: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+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
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pafex
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Dynamic: license-file
+
+# resion
+
+Minimal tree-based HTML parser built on the stdlib `html.parser`: an
+editable `Node` tree, basic selectors (tag, `#id`, `.class`), readable-text
+extraction and minification.
+
+## Install
+
+```bash
+pip install resion
+```
+
+## Usage
+
+```python
+import resion as rs
+
+doc = rs.parse('<h1 id="t">Title</h1><p class="lead">Hi</p>')
+
+doc.find('#t').text_content()        # 'Title'
+doc.find_all('p')                    # [Node p]
+doc.find('.lead').get_attr('class')  # 'lead'
+rs.extract_text(doc)                 # readable text, boilerplate removed
+rs.minify('<div> a </div><!-- x -->')
+```
+
+The tree is editable:
+
+```python
+from resion import Node
+
+doc.find('p').replace_with(Node('span'))
+node = doc.find('#t')
+node.set_attr('id', 'new').unwrap()
+doc.to_html()
+```
+
+Settings are a `Config` or plain dict merged over defaults; a
+`default.config` next to the package is auto-loaded at import (falling back
+to built-in defaults when absent):
+
+```python
+from resion import Config, Engine, get_config, load_config
+
+engine = Engine({'strict_mode': True})
+engine = Engine(load_config('my.config'))
+get_config().get('strict_mode', False)
+```
+
+Bytes input is decoded via BOM sniffing and `<meta charset>` detection;
+oversized input and malformed HTML are rejected in strict mode with
+`PafexError`.

resion-22.0.1/README.md

@@ -0,0 +1,52 @@
+# resion
+
+Minimal tree-based HTML parser built on the stdlib `html.parser`: an
+editable `Node` tree, basic selectors (tag, `#id`, `.class`), readable-text
+extraction and minification.
+
+## Install
+
+```bash
+pip install resion
+```
+
+## Usage
+
+```python
+import resion as rs
+
+doc = rs.parse('<h1 id="t">Title</h1><p class="lead">Hi</p>')
+
+doc.find('#t').text_content()        # 'Title'
+doc.find_all('p')                    # [Node p]
+doc.find('.lead').get_attr('class')  # 'lead'
+rs.extract_text(doc)                 # readable text, boilerplate removed
+rs.minify('<div> a </div><!-- x -->')
+```
+
+The tree is editable:
+
+```python
+from resion import Node
+
+doc.find('p').replace_with(Node('span'))
+node = doc.find('#t')
+node.set_attr('id', 'new').unwrap()
+doc.to_html()
+```
+
+Settings are a `Config` or plain dict merged over defaults; a
+`default.config` next to the package is auto-loaded at import (falling back
+to built-in defaults when absent):
+
+```python
+from resion import Config, Engine, get_config, load_config
+
+engine = Engine({'strict_mode': True})
+engine = Engine(load_config('my.config'))
+get_config().get('strict_mode', False)
+```
+
+Bytes input is decoded via BOM sniffing and `<meta charset>` detection;
+oversized input and malformed HTML are rejected in strict mode with
+`PafexError`.

resion-22.0.1/pyproject.toml

@@ -0,0 +1,42 @@
+[build-system]
+requires = ["setuptools>=69.5.1", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "resion"
+version = "22.0.1"
+description = "Minimal tree-based HTML parsing with basic selectors."
+readme = "README.md"
+license = "MIT"
+authors = [
+    {name = "hositel", email = "hositel@gmail.com"}
+]
+requires-python = ">=3.8"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3 :: Only",
+    "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",
+]
+
+dependencies = [
+    "pafex"
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest",
+    "pytest-cov",
+]
+
+[tool.setuptools]
+packages = ["resion"]
+
+[tool.setuptools.package-data]
+resion = [
+    "*.config"
+]

resion-22.0.1/resion/__init__.py

@@ -0,0 +1,53 @@
+"""Minimal tree-based HTML parsing built on pafex configuration."""
+
+from typing import Any, Dict, List, Union
+
+from pafex.config import Config, load_config, save_config
+from pafex.exceptions import ConfigLoadError, PafexError
+
+from . import core as _core
+from .core import Engine, Node, ParsedDocument, get_config, get_engine
+
+def _as_doc(target: Union[str, bytes, ParsedDocument]) -> ParsedDocument:
+    if isinstance(target, ParsedDocument):
+        return target
+    return _core.get_engine().parse(target)
+
+
+def parse(html: Union[str, bytes]) -> ParsedDocument:
+    """Parse HTML into a ParsedDocument using the active configuration."""
+    return _core.get_engine().parse(html)
+
+
+def select(target: Union[str, bytes, ParsedDocument],
+           selector: str) -> List[Dict[str, Any]]:
+    """Run a basic selector (tag, #id, .class); returns dicts per match."""
+    return [node.to_dict() for node in _as_doc(target).find_all(selector)]
+
+
+def extract_text(target: Union[str, bytes, ParsedDocument]) -> str:
+    """Extract readable text with boilerplate removal."""
+    return _as_doc(target).text()
+
+
+def minify(html: str) -> str:
+    """Minify HTML honoring remove_comments from the active configuration."""
+    return _core.get_engine().minify(html)
+
+
+__all__ = [
+    'Engine',
+    'Node',
+    'ParsedDocument',
+    'Config',
+    'load_config',
+    'save_config',
+    'get_config',
+    'get_engine',
+    'parse',
+    'select',
+    'extract_text',
+    'minify',
+    'PafexError',
+    'ConfigLoadError',
+]

resion-22.0.1/resion/core.py

@@ -0,0 +1,424 @@
+"""Minimal tree-based HTML parsing engine built on the stdlib html.parser."""
+
+import codecs
+import re
+from html import escape as _escape
+from html.parser import HTMLParser as _BaseHTMLParser
+from typing import Any, Dict, Iterator, List, Optional, Union
+
+from pafex.config import Config, load_config as _load_config
+from pafex.exceptions import PafexError
+
+from .utils import extract_doctype, minify_html
+
+VOID_ELEMENTS = {
+    'area', 'base', 'br', 'col', 'embed', 'hr', 'img', 'input',
+    'link', 'meta', 'param', 'source', 'track', 'wbr',
+}
+
+BLOCK_TAGS = {
+    'address', 'article', 'aside', 'blockquote', 'details', 'dialog', 'dd',
+    'div', 'dl', 'dt', 'fieldset', 'figcaption', 'figure', 'footer', 'form',
+    'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'header', 'hgroup', 'hr', 'li',
+    'main', 'nav', 'ol', 'p', 'pre', 'section', 'table', 'tbody', 'thead',
+    'tfoot', 'tr', 'ul',
+}
+
+ROOT_TAG = ':root'
+COMMENT_TAG = ':comment'
+
+PRESERVE_WHITESPACE_TAGS = {'pre', 'textarea'}
+
+
+def _resolve_config(config: Optional[Any] = None) -> Config:
+    """Normalize None, a plain dict or a Config into a Config instance."""
+    if config is None:
+        return Config()
+    if isinstance(config, Config):
+        return config
+    if isinstance(config, dict):
+        return Config(config)
+    return Config(config.to_dict())
+
+
+def detect_encoding(data: bytes, default: str = 'utf-8') -> str:
+    """Detect the encoding of raw HTML: BOM sniff, then <meta charset>."""
+    if data.startswith(codecs.BOM_UTF8):
+        return 'utf-8-sig'
+    if data.startswith((codecs.BOM_UTF32_LE, codecs.BOM_UTF32_BE)):
+        return 'utf-32'
+    if data.startswith((codecs.BOM_UTF16_LE, codecs.BOM_UTF16_BE)):
+        return 'utf-16'
+    head = data[:2048].decode('latin-1', errors='ignore')
+    match = re.search(
+        r'<meta[^>]+charset\s*=\s*["\']?\s*([\w.:+-]+)', head, re.IGNORECASE
+    )
+    if match:
+        try:
+            codecs.lookup(match.group(1))
+            return match.group(1)
+        except LookupError:
+            pass
+    return default
+
+
+class Node:
+    """A single element or comment node in the parsed HTML tree."""
+
+    def __init__(self, tag: str, attrs: Optional[Dict[str, str]] = None,
+                 parent: Optional['Node'] = None) -> None:
+        self.tag = tag
+        self.attrs: Dict[str, str] = dict(attrs or {})
+        self.children: List[Any] = []
+        self.parent: Optional[Node] = parent
+
+    @property
+    def is_comment(self) -> bool:
+        return self.tag == COMMENT_TAG
+
+    def get_attr(self, name: str, default: Optional[str] = None) -> Optional[str]:
+        return self.attrs.get(name, default)
+
+    def has_class(self, name: str) -> bool:
+        return name in (self.get_attr('class') or '').split()
+
+    def set_attr(self, name: str, value: str) -> 'Node':
+        self.attrs[name] = value
+        return self
+
+    def remove_attr(self, name: str) -> 'Node':
+        self.attrs.pop(name, None)
+        return self
+
+    def append_child(self, node: 'Node') -> 'Node':
+        if node.parent is not None:
+            node.parent.children.remove(node)
+        self.children.append(node)
+        node.parent = self
+        return self
+
+    def remove(self) -> 'Node':
+        if self.parent is not None:
+            self.parent.children.remove(self)
+            self.parent = None
+        return self
+
+    def replace_with(self, *nodes: 'Node') -> 'Node':
+        if self.parent is None:
+            raise PafexError('cannot replace a detached node')
+        siblings = self.parent.children
+        index = siblings.index(self)
+        replacements = list(nodes)
+        for node in replacements:
+            if node.parent is not None:
+                node.parent.children.remove(node)
+        siblings[index:index + 1] = replacements
+        for node in replacements:
+            node.parent = self.parent
+        self.parent = None
+        return self
+
+    def unwrap(self) -> 'Node':
+        if self.parent is None:
+            raise PafexError('cannot unwrap a detached node')
+        siblings = self.parent.children
+        index = siblings.index(self)
+        children = list(self.children)
+        siblings[index:index + 1] = children
+        for child in children:
+            if isinstance(child, Node):
+                child.parent = self.parent
+        self.children = []
+        self.parent = None
+        return self
+
+    def child_elements(self) -> List['Node']:
+        return [
+            child
+            for child in self.children
+            if isinstance(child, Node) and not child.is_comment
+        ]
+
+    def text_content(self) -> str:
+        parts: List[str] = []
+        for child in self.children:
+            if isinstance(child, str):
+                parts.append(child)
+            else:
+                parts.append(child.text_content())
+        return ''.join(parts)
+
+    def iter_elements(self) -> Iterator['Node']:
+        for child in self.children:
+            if isinstance(child, Node) and not child.is_comment:
+                yield child
+                yield from child.iter_elements()
+
+    def to_html(self) -> str:
+        if self.is_comment:
+            return f'<!--{self.text_content()}-->'
+        attrs = ''.join(
+            f' {name}' if value == '' else f' {name}="{_escape(value, quote=True)}"'
+            for name, value in self.attrs.items()
+        )
+        if self.tag in VOID_ELEMENTS:
+            return f'<{self.tag}{attrs}>'
+        inner = ''.join(
+            _escape(child, quote=False) if isinstance(child, str) else child.to_html()
+            for child in self.children
+        )
+        return f'<{self.tag}{attrs}>{inner}</{self.tag}>'
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            'tag': self.tag,
+            'attrs': dict(self.attrs),
+            'text': self.text_content().strip(),
+            'html': self.to_html(),
+        }
+
+    def __repr__(self) -> str:
+        return f'<Node {self.tag}>'
+
+
+class _TreeBuilder(_BaseHTMLParser):
+    """Builds a Node tree from HTML using the stdlib tokenizer."""
+
+    def __init__(self, settings: Any) -> None:
+        super().__init__(convert_charrefs=True)
+        self.settings = settings
+        self.root = Node(ROOT_TAG)
+        self._stack: List[Node] = [self.root]
+        self.comments: List[str] = []
+        self.errors: List[str] = []
+        self._max_depth = int(settings.get('max_depth', 100) or 100)
+        self._preserve_comments = bool(settings.get('preserve_comments', False))
+        self._strip_whitespace = bool(settings.get('strip_whitespace', True))
+        self._strict = bool(settings.get('strict_mode', False))
+
+    def _current(self) -> Node:
+        return self._stack[-1]
+
+    def _attach(self, node: Node) -> None:
+        parent = self._current()
+        if len(self._stack) <= self._max_depth:
+            parent.children.append(node)
+            node.parent = parent
+        elif self._strict:
+            self.errors.append(
+                f'<{node.tag}> exceeds max_depth={self._max_depth}'
+            )
+        self._stack.append(node)
+
+    def handle_starttag(self, tag, attrs) -> None:
+        node = Node(tag, {k: (v if v is not None else '') for k, v in attrs})
+        self._attach(node)
+        if tag in VOID_ELEMENTS:
+            self._stack.pop()
+
+    def handle_startendtag(self, tag, attrs) -> None:
+        node = Node(tag, {k: (v if v is not None else '') for k, v in attrs})
+        if len(self._stack) <= self._max_depth:
+            parent = self._current()
+            parent.children.append(node)
+            node.parent = parent
+
+    def handle_endtag(self, tag) -> None:
+        if tag in VOID_ELEMENTS:
+            return
+        for i in range(len(self._stack) - 1, 0, -1):
+            if self._stack[i].tag == tag:
+                if len(self._stack) - 1 > i:
+                    unclosed = [n.tag for n in self._stack[i + 1:]]
+                    self.errors.append(
+                        f'unclosed tag(s) <{"> <".join(unclosed)}> before </{tag}>'
+                    )
+                del self._stack[i:]
+                return
+        self.errors.append(f'closing tag </{tag}> has no matching open tag')
+
+    def handle_data(self, data) -> None:
+        if not data:
+            return
+        if self._strip_whitespace and not any(
+            node.tag in PRESERVE_WHITESPACE_TAGS for node in self._stack
+        ):
+            data = re.sub(r'\s+', ' ', data)
+        self._current().children.append(data)
+
+    def handle_comment(self, data) -> None:
+        self.comments.append(data)
+        if self._preserve_comments:
+            comment = Node(COMMENT_TAG)
+            comment.children.append(data)
+            if len(self._stack) <= self._max_depth:
+                parent = self._current()
+                parent.children.append(comment)
+                comment.parent = parent
+
+    def close(self) -> None:
+        super().close()
+        if len(self._stack) > 1:
+            unclosed = [n.tag for n in self._stack[1:]]
+            self.errors.append(
+                f'unclosed tag(s) at end of input: <{"> <".join(unclosed)}>'
+            )
+
+
+def _match_basic(node: Node, selector: str) -> bool:
+    if selector.startswith('#'):
+        return node.get_attr('id') == selector[1:]
+    if selector.startswith('.'):
+        return node.has_class(selector[1:])
+    return node.tag.lower() == selector.lower()
+
+
+def _find_all_basic(root: Node, selector: str) -> List[Node]:
+    selector = selector.strip()
+    if not selector or any(char.isspace() for char in selector):
+        raise PafexError(
+            f'unsupported selector {selector!r}; only tag, #id and .class are supported'
+        )
+    return [node for node in root.iter_elements() if _match_basic(node, selector)]
+
+
+class ParsedDocument:
+    """Structured, lazily-enriched result of parsing an HTML document."""
+
+    def __init__(self, doctype: Optional[str], root: Node,
+                 comments: Optional[List[str]] = None,
+                 config: Optional[Any] = None,
+                 errors: Optional[List[str]] = None) -> None:
+        self.doctype = doctype
+        self.root = root
+        self.comments = comments or []
+        self.errors = errors or []
+        self.config: Config = _resolve_config(config)
+        self._text: Optional[str] = None
+
+    def text(self) -> str:
+        from .utils import extract_text
+        if self._text is None:
+            self._text = extract_text(self)
+        return self._text
+
+    def find_all(self, selector: str) -> List[Node]:
+        """Return every element matching a basic selector (tag, #id, .class)."""
+        return _find_all_basic(self.root, selector)
+
+    def find(self, selector: str) -> Optional[Node]:
+        """Return the first element matching a basic selector, or None."""
+        nodes = _find_all_basic(self.root, selector)
+        return nodes[0] if nodes else None
+
+    def to_html(self) -> str:
+        return ''.join(
+            _escape(child, quote=False) if isinstance(child, str) else child.to_html()
+            for child in self.root.children
+        )
+
+    def stats(self) -> Dict[str, int]:
+        element_count = 0
+        max_depth = 0
+
+        def walk(node: Node, depth: int) -> None:
+            nonlocal element_count, max_depth
+            for child in node.children:
+                if isinstance(child, Node) and not child.is_comment:
+                    element_count += 1
+                    if depth + 1 > max_depth:
+                        max_depth = depth + 1
+                    walk(child, depth + 1)
+
+        walk(self.root, 0)
+        return {
+            'elements': element_count,
+            'comments': len(self.comments),
+            'max_depth': max_depth,
+        }
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            'doctype': self.doctype,
+            'stats': self.stats(),
+            'text': self.text(),
+            'comments': list(self.comments),
+            'errors': list(self.errors),
+        }
+
+    def __repr__(self) -> str:
+        return f'<ParsedDocument {self.stats()["elements"]} elements>'
+
+
+class Engine:
+    """High-level HTML processing engine configured by a Config or dict."""
+
+    def __init__(self, config: Optional[Any] = None) -> None:
+        self.config: Config = _resolve_config(config)
+
+    def parse(self, html: Union[str, bytes]) -> ParsedDocument:
+        """Parse HTML (str or bytes) into a ParsedDocument."""
+        if isinstance(html, bytes):
+            encoding = detect_encoding(
+                html,
+                default=str(self.config.get('encoding', 'utf-8') or 'utf-8'),
+            )
+            html = html.decode(encoding, errors='replace')
+        self._check_size(html)
+        builder = _TreeBuilder(self.config)
+        try:
+            builder.feed(html)
+            builder.close()
+        except Exception as exc:
+            raise PafexError(f'failed to parse HTML: {exc}') from exc
+        if bool(self.config.get('strict_mode', False)) and builder.errors:
+            summary = '; '.join(builder.errors[:5])
+            raise PafexError(f'malformed HTML (strict mode): {summary}')
+        return ParsedDocument(
+            doctype=extract_doctype(html),
+            root=builder.root,
+            comments=builder.comments,
+            config=self.config,
+            errors=builder.errors,
+        )
+
+    def _check_size(self, html: str) -> None:
+        cap = self.config.get('max_file_size_mb', 10)
+        if not cap:
+            return
+        size_mb = len(html.encode('utf-8', errors='replace')) / (1024 * 1024)
+        if size_mb > float(cap):
+            raise PafexError(
+                f'input of {size_mb:.2f} MB exceeds max_file_size_mb={cap}'
+            )
+
+    def minify(self, html: str) -> str:
+        """Minify HTML honoring remove_comments from the settings."""
+        return minify_html(
+            html, remove_comments=bool(self.config.get('remove_comments', True))
+        )
+
+
+def parse_raw(html: Union[str, bytes],
+              config: Optional[Any] = None) -> ParsedDocument:
+    """Parse with whitespace preserved."""
+    cfg = _resolve_config(config).update({'strip_whitespace': False})
+    return Engine(cfg).parse(html)
+
+
+try:
+    config = _load_config(None)
+except Exception:
+    config = Config()
+
+_engine = Engine(config)
+
+
+def get_config() -> Config:
+    """Return the active configuration object."""
+    return config
+
+
+def get_engine() -> Engine:
+    """Return the active parsing engine."""
+    return _engine

resion-22.0.1/resion/utils.py

@@ -0,0 +1,69 @@
+"""Minimal HTML helpers: doctype extraction, minification and text extraction."""
+
+import re
+from typing import Optional
+
+_SKIP_TEXT_TAGS = {'script', 'style', 'noscript', 'template', 'head'}
+_BOILERPLATE_TAGS = {'nav', 'footer'}
+_BOILERPLATE_NAME_RE = re.compile(
+    r'\b(nav|navbar|menu|sidebar|header|footer|banner|advert|ads?|promo|breadcrumb)\b',
+    re.IGNORECASE,
+)
+
+
+def minify_html(html: str, remove_comments: bool = True) -> str:
+    """Minify HTML by removing unnecessary whitespace and optional comments."""
+    if remove_comments:
+        html = re.sub(r'<!--(.*?)-->', '', html, flags=re.DOTALL)
+
+    html = re.sub(r'[ \t]+', ' ', html)
+    html = re.sub(r'\s+<(div|p|h[1-6]|br|hr|ul|ol|li|table|tr|td|th|head|body|html)', r'<\1', html)
+    html = re.sub(r'</(div|p|h[1-6]|ul|ol|li|table|tr|td|th|head|body|html)>\s+', r'</\1>', html)
+    return html.strip()
+
+
+def extract_doctype(html: str) -> Optional[str]:
+    """Extract the DOCTYPE declaration from HTML."""
+    match = re.search(r'<!DOCTYPE\s+([^>]+)>', html, re.IGNORECASE)
+    return match.group(0) if match else None
+
+
+def _is_boilerplate(node) -> bool:
+    if node.tag in _BOILERPLATE_TAGS:
+        return True
+    identity = f"{node.get_attr('class') or ''} {node.get_attr('id') or ''}"
+    return bool(_BOILERPLATE_NAME_RE.search(identity))
+
+
+def extract_text(doc) -> str:
+    """Extract readable text, dropping scripts/styles and common boilerplate
+    elements while preserving block-level line structure."""
+    from .core import BLOCK_TAGS, Node
+
+    parts = []
+
+    def walk(node) -> None:
+        for child in node.children:
+            if isinstance(child, str):
+                parts.append(child)
+                continue
+            if child.is_comment:
+                continue
+            if child.tag in _SKIP_TEXT_TAGS or _is_boilerplate(child):
+                continue
+            if child.tag == 'br':
+                parts.append('\n')
+                continue
+            block = child.tag in BLOCK_TAGS
+            if block:
+                parts.append('\n')
+            walk(child)
+            if block:
+                parts.append('\n')
+
+    walk(doc.root)
+    text = ''.join(parts)
+    text = re.sub(r'[ \t]+', ' ', text)
+    text = re.sub(r' ?\n ?', '\n', text)
+    text = re.sub(r'\n{3,}', '\n\n', text)
+    return text.strip()

resion-22.0.1/resion.egg-info/PKG-INFO

@@ -0,0 +1,75 @@
+Metadata-Version: 2.4
+Name: resion
+Version: 22.0.1
+Summary: Minimal tree-based HTML parsing with basic selectors.
+Author-email: hositel <hositel@gmail.com>
+License-Expression: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+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
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pafex
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Dynamic: license-file
+
+# resion
+
+Minimal tree-based HTML parser built on the stdlib `html.parser`: an
+editable `Node` tree, basic selectors (tag, `#id`, `.class`), readable-text
+extraction and minification.
+
+## Install
+
+```bash
+pip install resion
+```
+
+## Usage
+
+```python
+import resion as rs
+
+doc = rs.parse('<h1 id="t">Title</h1><p class="lead">Hi</p>')
+
+doc.find('#t').text_content()        # 'Title'
+doc.find_all('p')                    # [Node p]
+doc.find('.lead').get_attr('class')  # 'lead'
+rs.extract_text(doc)                 # readable text, boilerplate removed
+rs.minify('<div> a </div><!-- x -->')
+```
+
+The tree is editable:
+
+```python
+from resion import Node
+
+doc.find('p').replace_with(Node('span'))
+node = doc.find('#t')
+node.set_attr('id', 'new').unwrap()
+doc.to_html()
+```
+
+Settings are a `Config` or plain dict merged over defaults; a
+`default.config` next to the package is auto-loaded at import (falling back
+to built-in defaults when absent):
+
+```python
+from resion import Config, Engine, get_config, load_config
+
+engine = Engine({'strict_mode': True})
+engine = Engine(load_config('my.config'))
+get_config().get('strict_mode', False)
+```
+
+Bytes input is decoded via BOM sniffing and `<meta charset>` detection;
+oversized input and malformed HTML are rejected in strict mode with
+`PafexError`.

resion-22.0.1/resion.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+LICENSE
+README.md
+pyproject.toml
+resion/__init__.py
+resion/core.py
+resion/default.config
+resion/utils.py
+resion.egg-info/PKG-INFO
+resion.egg-info/SOURCES.txt
+resion.egg-info/dependency_links.txt
+resion.egg-info/requires.txt
+resion.egg-info/top_level.txt

resion-22.0.1/resion.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

resion-22.0.1/resion.egg-info/requires.txt

@@ -0,0 +1,5 @@
+pafex
+
+[dev]
+pytest
+pytest-cov

resion-22.0.1/resion.egg-info/top_level.txt

@@ -0,0 +1 @@
+resion

resion-22.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+