pafer 0.9.7__py3-none-any.whl

pafer/__init__.py

@@ -0,0 +1,26 @@
+
+from .pafer import HTMLParser
+from .config import Config, DEFAULT_CONFIG, load_config, save_config
+from .exceptions import (
+    HTMLParserError,
+    SanitizationError,
+    SelectorSyntaxError,
+    ConfigLoadError
+)
+from .utils import minify_html, is_probably_html
+
+from . import cache, feed, exporters
+
+__all__ = [
+    'HTMLParser',
+    'Config',
+    'DEFAULT_CONFIG',
+    'load_config',
+    'save_config',
+    'minify_html',
+    'is_probably_html',
+    'cache',
+    'feed',
+    'exporters',
+    'HTMLParserError'
+]

pafer/cache.py

@@ -0,0 +1,50 @@
+"""
+In-memory caching system for parsed documents.
+"""
+
+import time
+from collections import OrderedDict
+from typing import Any, Dict, Optional, Tuple
+
+
+class LRUCache:
+    """In-memory LRU cache with TTL support for parsed documents."""
+
+    def __init__(self, max_size: int = 100, ttl_seconds: int = 300):
+        self.max_size = max_size
+        self.ttl = ttl_seconds
+        self._cache: Dict[str, Tuple[Any, float]] = OrderedDict()
+
+    def get(self, key: str) -> Optional[Any]:
+        entry = self._cache.get(key)
+        if entry is None:
+            return None
+        value, timestamp = entry
+        if time.time() - timestamp >= self.ttl:
+            del self._cache[key]
+            return None
+        self._cache.move_to_end(key)
+        return value
+
+    def set(self, key: str, value: Any) -> None:
+        self._purge_expired()
+        if key in self._cache:
+            self._cache.move_to_end(key)
+        self._cache[key] = (value, time.time())
+        while len(self._cache) > self.max_size:
+            self._cache.popitem(last=False)
+
+    def _purge_expired(self) -> None:
+        now = time.time()
+        expired = [
+            key for key, (_, timestamp) in self._cache.items()
+            if now - timestamp >= self.ttl
+        ]
+        for key in expired:
+            del self._cache[key]
+
+    def clear(self) -> None:
+        self._cache.clear()
+
+    def __len__(self) -> int:
+        return len(self._cache)

pafer/cli.py

@@ -0,0 +1,52 @@
+"""
+Command line interface for HTMLParser.
+"""
+
+import argparse
+import sys
+
+from .pafer import HTMLParser
+
+
+def run_cli():
+    pafer_cli = argparse.ArgumentParser(
+        description='HTMLParser - Enterprise HTML Processing Tool',
+        epilog='Example: htmlpafer parse -f input.html --minify'
+    )
+
+    subpafers = pafer_cli.add_subpafers(dest='command', help='Available commands')
+
+    parse_cmd = subpafers.add_pafer('parse', help='Parse an HTML file')
+    parse_cmd.add_argument('-f', '--file', required=True, help='Path to HTML file')
+    parse_cmd.add_argument('--minify', action='store_true', help='Minify output')
+
+    sanit_cmd = subpafers.add_pafer('sanitize', help='Sanitize an HTML file')
+    sanit_cmd.add_argument('-f', '--file', required=True, help='Path to HTML file')
+
+    args = pafer_cli.parse_args()
+
+    if args.command == 'parse':
+        try:
+            with open(args.file, 'r') as f:
+                html = f.read()
+
+            p = HTMLParser()
+            if args.minify:
+                html = p.minify(html)
+
+            result = p.parse(html)
+            print(f"[+] Parsed {len(result['tags'])} tags successfully.")
+
+        except FileNotFoundError:
+            print(f"[-] Error: File '{args.file}' not found.")
+            sys.exit(1)
+
+    elif args.command == 'sanitize':
+        print('[+] Sanitization not implemented in CLI yet.')
+
+    else:
+        pafer_cli.print_help()
+
+
+if __name__ == '__main__':
+    run_cli()

pafer/config.py

@@ -0,0 +1,115 @@
+"""
+Configuration loading and persistence for the pafer package.
+"""
+
+import os
+import pickle
+import tempfile
+from pathlib import Path
+from typing import Any, Dict, Optional, Union
+
+from .exceptions import ConfigLoadError
+
+PathLike = Union[str, os.PathLike]
+
+DEFAULT_CONFIG: Dict[str, Any] = {
+    'parse_tables': True,
+    'strip_whitespace': True,
+    'encoding': 'utf-8',
+    'max_depth': 100,
+    'default_tag': 'div',
+    'preserve_comments': False,
+    'strict_mode': False,
+    'remove_comments': True,
+    'allowed_tags': {'p', 'br', 'b', 'i', 'a', 'ul', 'ol', 'li', 'div', 'span'},
+    'max_file_size_mb': 10,
+    'cache_size': 50
+}
+
+def _sanitize_value(value: Any) -> Any:
+    """Recursively verify that a value only contains allowed plain types."""
+    if isinstance(value, (str, bytes, int, float, bool, type(None))):
+        return value
+    if isinstance(value, dict):
+        return {str(key): _sanitize_value(item) for key, item in value.items()}
+    if isinstance(value, (list, tuple)):
+        return [_sanitize_value(item) for item in value]
+    if isinstance(value, (set, frozenset)):
+        return {_sanitize_value(item) for item in value}
+    raise ConfigLoadError(
+        f'disallowed type {type(value).__name__!r} in config file; '
+        'only plain data types are allowed'
+    )
+
+
+class Config:
+    """Configuration holder that layers user settings over DEFAULT_CONFIG."""
+
+    def __init__(self, settings: Optional[Dict[str, Any]] = None):
+        self._settings: Dict[str, Any] = {**DEFAULT_CONFIG, **(settings or {})}
+
+    def get(self, key: str, default: Any = None) -> Any:
+        return self._settings.get(key, default)
+
+    def update(self, settings: Dict[str, Any]) -> 'Config':
+        """Return a new Config with extra settings layered on top of this one."""
+        return Config({**self._settings, **(settings or {})})
+
+    def to_dict(self) -> Dict[str, Any]:
+        return dict(self._settings)
+
+    @classmethod
+    def load_default(cls) -> 'Config':
+        """Return a Config built from DEFAULT_CONFIG without reading any file."""
+        return cls()
+
+    def __eq__(self, other: Any) -> bool:
+        if isinstance(other, Config):
+            return self._settings == other._settings
+        return NotImplemented
+
+    def __repr__(self) -> str:
+        return f'Config({self._settings})'
+
+
+def _read_pkl(path: PathLike) -> Dict[str, Any]:
+    """Read a pickled dict from path."""
+    try:
+        with open(path, 'rb') as handle:
+            data = pickle.load(handle)
+    except ConfigLoadError:
+        raise
+    except Exception as exc:
+        raise ConfigLoadError(f"failed to read config file '{path}': {exc}") from exc
+    if not isinstance(data, dict):
+        raise ConfigLoadError(
+            f"config file '{path}' must contain a dict, "
+            f"got {type(data).__name__}"
+        )
+    return _sanitize_value(data)
+
+
+def load_config(path: PathLike) -> Config:
+    """Load a Config from a caller-supplied pickle file."""
+    return Config(_read_pkl(path))
+
+
+def save_config(config: Config, path: PathLike) -> Path:
+    """Persist a Config to path atomically."""
+    settings = config.to_dict()
+    target = Path(path)
+    if not target.parent.exists():
+        target.parent.mkdir(parents=True, exist_ok=True)
+
+    fd, tmp_name = tempfile.mkstemp(dir=str(target.parent), suffix='.pkl.tmp')
+    try:
+        with os.fdopen(fd, 'wb') as handle:
+            pickle.dump(settings, handle, protocol=pickle.HIGHEST_PROTOCOL)
+        os.replace(tmp_name, str(target))
+    except Exception:
+        try:
+            os.unlink(tmp_name)
+        except OSError:
+            pass
+        raise
+    return target

pafer/exceptions.py

@@ -0,0 +1,18 @@
+"""
+Custom exceptions for HTMLParser.
+"""
+
+class HTMLParserError(Exception):
+    """Base exception for all HTMLParser errors."""
+
+
+class SanitizationError(HTMLParserError):
+    """Raised when HTML sanitization fails or encounters malicious patterns."""
+
+
+class SelectorSyntaxError(HTMLParserError):
+    """Raised when a CSS selector is invalid."""
+
+
+class ConfigLoadError(HTMLParserError):
+    """Raised when configuration cannot be loaded."""

pafer/exporters.py

@@ -0,0 +1,23 @@
+"""
+Export parsed HTML data to standard formats.
+"""
+
+import csv
+import io
+import json
+from typing import Any, Dict, List
+
+
+class DataExporter:
+    """Export parsed HTML data to standard formats."""
+
+    @staticmethod
+    def to_csv(rows: List[List[str]]) -> str:
+        output = io.StringIO()
+        writer = csv.writer(output)
+        writer.writerows(rows)
+        return output.getvalue()
+
+    @staticmethod
+    def to_json(data: Dict[str, Any], indent: int = 2) -> str:
+        return json.dumps(data, indent=indent, default=str)

pafer/feed.py

@@ -0,0 +1,23 @@
+"""
+RSS feed item extraction.
+"""
+
+import re
+from typing import Dict, List
+
+
+class FeedParser:
+
+    def __init__(self):
+        self.item_pattern = re.compile(r'<item.*?>(.*?)</item>', re.DOTALL)
+        self.tag_pattern = re.compile(r'<(title|link|description|pubDate)>(.*?)</\1>', re.DOTALL)
+
+    def parse_rss(self, xml_content: str) -> List[Dict]:
+        """Extract <item> entries as dicts of their child tags."""
+        items = []
+        for match in self.item_pattern.finditer(xml_content):
+            tags = dict(self.tag_pattern.findall(match.group(1)))
+            if 'description' in tags:
+                tags['description'] = re.sub(r'<[^>]+>', '', tags['description'])
+            items.append(tags)
+        return items

pafer/pafer.py

@@ -0,0 +1,126 @@
+"""
+HTML Parser implementation with sanitization and selectors.
+"""
+
+import re
+from typing import List, Dict, Optional, Set
+
+from .config import Config
+from .utils import minify_html, extract_doctype
+
+
+class HTMLParser:
+    """Parse, extract, and sanitize HTML content."""
+
+    def __init__(self, config: Optional[Config] = None, use_cache: bool = False):
+        self.config = config or Config()
+        self._tag_pattern = re.compile(r'<(\w+)([^>]*)>(.*?)</\1>', re.DOTALL)
+        self._attr_pattern = re.compile(r'(\w+)=["\']([^"\']*)["\']')
+
+        self.cache = None
+        if use_cache:
+            from .cache import LRUCache
+            self.cache = LRUCache(max_size=self.config.get('cache_size', 50))
+
+    def parse(self, html: str) -> Dict:
+        """Parse HTML and return structured data."""
+        if self.cache:
+            cached = self.cache.get(html)
+            if cached:
+                return cached
+
+        result = {
+            'tags': [],
+            'text': [],
+            'metadata': {},
+            'doctype': extract_doctype(html)
+        }
+
+        if self.config.get('strip_whitespace', True):
+            html = re.sub(r'\s+', ' ', html).strip()
+
+        for match in self._tag_pattern.finditer(html):
+            tag_name, attrs_str, content = match.groups()
+            attrs = dict(self._attr_pattern.findall(attrs_str))
+
+            tag_data = {
+                'name': tag_name,
+                'attributes': attrs,
+                'content': content.strip() if self.config.get('strip_whitespace') else content
+            }
+
+            if self.config.get('parse_tables', True) and tag_name == 'table':
+                tag_data['rows'] = self._parse_table(content)
+
+            result['tags'].append(tag_data)
+
+        title_match = re.search(r'<title>(.*?)</title>', html, re.IGNORECASE)
+        if title_match:
+            result['metadata']['title'] = title_match.group(1)
+
+        if self.cache:
+            self.cache.set(html, result)
+        return result
+
+    def select(self, html: str, selector: str) -> List[Dict]:
+        """Basic CSS selector simulation (ID, class and tag selectors)."""
+        if selector.startswith('#'):
+            attr_search = f'id="{selector[1:]}"'
+        elif selector.startswith('.'):
+            attr_search = f'class="{selector[1:]}"'
+        else:
+            attr_search = f'<{selector} '
+
+        results = []
+        for match in self._tag_pattern.finditer(html):
+            tag_name, attrs_str, content = match.groups()
+            if attr_search in attrs_str or attr_search in f'<{tag_name} ':
+                results.append({
+                    'tag': tag_name,
+                    'attrs': dict(self._attr_pattern.findall(attrs_str)),
+                    'inner_html': content
+                })
+        return results
+
+    def sanitize(self, html: str, allowed_tags: Optional[Set[str]] = None) -> str:
+        """Strip out tags that aren't in the allowed list."""
+        if allowed_tags is None:
+            allowed_tags = self.config.get('allowed_tags') or {
+                'p', 'br', 'b', 'i', 'a', 'ul', 'ol', 'li', 'div', 'span'
+            }
+
+        def replace_tag(match):
+            tag = match.group(1)
+            return match.group(0) if tag.lower() in allowed_tags else ''
+
+        cleaned = re.sub(r'</(\w+)>', replace_tag, html, flags=re.IGNORECASE)
+        cleaned = re.sub(r'<(\w+)([^>]*)>', replace_tag, cleaned, flags=re.IGNORECASE)
+        return cleaned
+
+    def minify(self, html: str) -> str:
+        """Minify HTML based on config settings."""
+        return minify_html(html, remove_comments=self.config.get('remove_comments', True))
+
+    def _parse_table(self, table_html: str) -> List[List[str]]:
+        rows = []
+        row_pattern = re.compile(r'<tr[^>]*>(.*?)</tr>', re.DOTALL)
+        cell_pattern = re.compile(r'<t[dh][^>]*>(.*?)</t[dh]>', re.DOTALL)
+        for row_match in row_pattern.finditer(table_html):
+            cells = [c.strip() for c in cell_pattern.findall(row_match.group(1))]
+            if cells:
+                rows.append(cells)
+        return rows
+
+    def extract_links(self, html: str) -> List[Dict]:
+        """Extract all links from HTML."""
+        links = []
+        link_pattern = re.compile(r'<a\s+([^>]*)>(.*?)</a>', re.DOTALL)
+        for match in link_pattern.finditer(html):
+            attrs = dict(self._attr_pattern.findall(match.group(1)))
+            if 'href' in attrs:
+                links.append({
+                    'url': attrs['href'],
+                    'text': match.group(2).strip(),
+                    'attributes': {k: v for k, v in attrs.items() if k != 'href'}
+                })
+        return links

pafer/utils.py

@@ -0,0 +1,29 @@
+"""
+Utility functions for HTML processing.
+"""
+
+import re
+from typing import Optional
+
+
+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_probably_html(content: str) -> bool:
+    """Heuristic check to determine if string is HTML."""
+    html_indicators = [r'<html', r'<head', r'<body', r'<div', r'<!DOCTYPE']
+    return any(re.search(pattern, content, re.IGNORECASE) for pattern in html_indicators)

pafer-0.9.7.dist-info/METADATA

@@ -0,0 +1,142 @@
+Metadata-Version: 2.4
+Name: pafer
+Version: 0.9.7
+Summary: Regex-based HTML parsing.
+Author-email: werson <werson.tech@gmail.com>
+License: MIT
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+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
+Classifier: Topic :: Software Development :: User Interfaces
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Dynamic: license-file
+
+![Python](https://img.shields.io/badge/python-3.8%2B-blue)
+![Dependencies](https://img.shields.io/badge/dependencies-none-success)
+![Tests](https://img.shields.io/badge/tests-pytest-informational)
+
+## Features
+
+- Parse HTML into structured tag / text / metadata results
+- CSS-style selectors (`#id`, `.class`, tag name)
+- Whitelist-based sanitization
+- Minification with comment stripping
+- Link and table extraction
+- LRU result caching with TTL
+- RSS 2.0 feed parsing
+- JSON / CSV export
+- CLI tool
+- Standard library only, no third-party dependencies
+
+## Installation
+
+```
+pip install pafer
+```
+
+## Quickstart
+
+```python
+from pafer import HTMLParser
+
+html = '<div class="post"><h1>Title</h1><a href="/about">About</a></div>'
+
+p = HTMLParser()
+result = p.parse(html)
+
+result['tags']        # list of {name, attributes, content, rows?}
+result['metadata']    # {'title': ...}
+result['doctype']     # '<!DOCTYPE ...>' or None
+
+p.select(html, '.post')    # match by #id, .class or tag name
+p.sanitize(html)           # keep only allowed tags
+p.minify(html)             # collapse whitespace, strip comments
+p.extract_links(html)      # [{'url': ..., 'text': ..., 'attributes': ...}]
+```
+
+Enable the parsed-result cache with `HTMLParser(use_cache=True)`.
+
+## Configuration
+
+```python
+from pafer import Config, load_config, save_config
+
+cfg = Config({'strip_whitespace': False, 'cache_size': 100})
+save_config(cfg, 'my.pkl')
+cfg = load_config('my.pkl')
+```
+
+### Default settings
+
+| Key | Default | Purpose |
+|---|---|---|
+| `parse_tables` | `True` | extract table rows while parsing |
+| `strip_whitespace` | `True` | collapse whitespace |
+| `encoding` | `utf-8` | decode bytes input |
+| `max_depth` | `100` | maximum element nesting |
+| `default_tag` | `div` | fallback tag |
+| `preserve_comments` | `False` | keep comments in the tree |
+| `strict_mode` | `False` | raise on malformed HTML |
+| `remove_comments` | `True` | strip comments when minifying |
+| `allowed_tags` | `p, br, b, i, a, ul, ol, li, div, span` | sanitize whitelist |
+| `max_file_size_mb` | `10` | reject oversized input |
+| `cache_size` | `50` | cache capacity |
+
+## Caching
+
+`pafer.cache.LRUCache` is an in-memory LRU cache with TTL expiry:
+
+```python
+from pafer.cache import LRUCache
+
+cache = LRUCache(max_size=100, ttl_seconds=300)
+cache.set('key', value)
+cache.get('key')
+```
+
+## RSS feeds
+
+```python
+from pafer.feed import FeedParser
+
+items = FeedParser().parse_rss(xml_content)
+items[0]['title']       # 'title', 'link', 'description', 'pubDate'
+```
+
+## Exporting
+
+```python
+from pafer.exporters import DataExporter
+
+DataExporter.to_json(data)    # JSON string with 2-space indent
+DataExporter.to_csv(rows)     # CSV from a list of rows
+```
+
+## CLI
+
+```
+python -m pafer.cli parse -f input.html --minify
+python -m pafer.cli sanitize -f input.html
+```
+
+## Exceptions
+
+`HTMLParserError` (base), `SanitizationError`, `SelectorSyntaxError`, `ConfigLoadError`.
+
+## LICENSE
+
+MIT - Enjoy
+

pafer-0.9.7.dist-info/RECORD

@@ -0,0 +1,14 @@
+pafer/__init__.py,sha256=qfif1-tLgzb_L6E5dXvFrjr7KLHlUzlN-enrUQz-LSw,518
+pafer/cache.py,sha256=_jLK3Cy9gZeKqdGqQGZ2lT3hGTyuMU9BB4Lb0MWWxrg,1442
+pafer/cli.py,sha256=uUha1YFXnHtNYsFkWIyomjewOlvv9GAoXt1fDjIHREM,1459
+pafer/config.py,sha256=RJ0lXrBrlbpW_SiUD1K5QGuyvm7wwdfH-3WAbJkcYG8,3669
+pafer/exceptions.py,sha256=ThlTAu9APDe6eASRgJD9DA4L314GTLZd12w39mX1Sjk,444
+pafer/exporters.py,sha256=fg_4ghpDFQQpcVp3y5dMIfszOqKJENhpKj2qEnSyfVk,537
+pafer/feed.py,sha256=JiqfAMTCOWpVbqe--WXmwlSmcZK4gP36_HZIwtVAvtY,738
+pafer/pafer.py,sha256=Lg6cHaiEakNvD8jzYFc_SrLwHXafLCTXX5bTaRLzBrA,4690
+pafer/utils.py,sha256=ztX76pEHUFHQbFO5VXIUxfGrAVLU1QOAMOviA9AaC1U,1073
+pafer-0.9.7.dist-info/licenses/LICENSE,sha256=v9KUTIwaghzDXke5a-bW9MVCQ27384A6Kse-TOKAIjc,1083
+pafer-0.9.7.dist-info/METADATA,sha256=zLrmLrvkEF2SHiJMiytczEor-f5poTt2soQYL6qAuXA,4053
+pafer-0.9.7.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+pafer-0.9.7.dist-info/top_level.txt,sha256=j9GNkUuPhxx2Smbk3kCwy7rbdq09_NjRkZ-suhl0glQ,6
+pafer-0.9.7.dist-info/RECORD,,

pafer-0.9.7.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

pafer-0.9.7.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 pafer
+
+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.

pafer-0.9.7.dist-info/top_level.txt

@@ -0,0 +1 @@
+pafer