librario 0.1.0__tar.gz

librario-0.1.0/PKG-INFO

@@ -0,0 +1,5 @@
+Metadata-Version: 2.4
+Name: librario
+Version: 0.1.0
+Summary: A small keyboard-first text web browser for the terminal
+Requires-Python: >=3.10

librario-0.1.0/README.md

@@ -0,0 +1,37 @@
+# Librario
+
+Librario is a deliberately small, text-first web browser for your terminal. Search results are navigated with the arrow keys (or `j`/`k`); press Enter to open a stripped-down readable page.
+
+## Install
+
+The quick, dependency-free way is to put the included launcher on your path:
+
+```sh
+mkdir -p ~/.local/bin
+ln -sf "$(pwd)/bin/librario" ~/.local/bin/librario
+```
+
+Ensure `~/.local/bin` is in your `PATH`, then run:
+
+```sh
+librario search "query here"
+```
+
+It can also be packaged with a normal Python environment that has `setuptools` installed:
+
+```sh
+python3 -m pip install --user .
+```
+
+## Use
+
+```sh
+librario search "weather on mars"
+```
+
+- `↑` / `↓` or `j` / `k`: move or scroll
+- `Enter`: open selected result
+- `b` or `Esc`: return to results
+- `q`: quit
+
+Librario retrieves search results from Bing’s RSS endpoint and makes normal HTTPS requests for pages. Some JavaScript-only, login-protected, or anti-bot-heavy sites will not provide usable text—alas, the modern web occasionally wears its pages like a hat.

librario-0.1.0/librario/__init__.py

@@ -0,0 +1 @@
+"""Librario: a tiny text-first terminal browser."""

librario-0.1.0/librario/__main__.py

@@ -0,0 +1,230 @@
+from __future__ import annotations
+
+import argparse
+import curses
+import html
+import re
+import sys
+import textwrap
+import urllib.parse
+import urllib.request
+import xml.etree.ElementTree as ET
+from dataclasses import dataclass
+from html.parser import HTMLParser
+
+USER_AGENT = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124 Safari/537.36"
+BLOCK_TAGS = {"p", "div", "section", "article", "main", "header", "footer", "aside", "li", "br", "h1", "h2", "h3", "h4", "h5", "h6", "tr"}
+SKIP_TAGS = {"script", "style", "noscript", "svg", "canvas", "iframe", "nav"}
+
+
+@dataclass
+class Result:
+    title: str
+    url: str
+    snippet: str = ""
+
+
+def request(url: str) -> str:
+    req = urllib.request.Request(url, headers={"User-Agent": USER_AGENT, "Accept": "text/html,application/xhtml+xml"})
+    with urllib.request.urlopen(req, timeout=15) as response:
+        charset = response.headers.get_content_charset() or "utf-8"
+        return response.read().decode(charset, errors="replace")
+
+
+class SearchParser(HTMLParser):
+    def __init__(self):
+        super().__init__()
+        self.results: list[Result] = []
+        self._href: str | None = None
+        self._title: list[str] = []
+        self._snippet: list[str] = []
+        self._in_result = False
+        self._in_snippet = False
+        self._snippet_target: Result | None = None
+
+    def handle_starttag(self, tag, attrs):
+        attrs = dict(attrs)
+        classes = attrs.get("class", "")
+        if tag == "a" and "result__a" in classes:
+            self._href, self._title, self._snippet, self._in_result = attrs.get("href"), [], [], True
+        elif tag in {"a", "div"} and "result__snippet" in classes and self.results:
+            self._snippet_target = self.results[-1]
+            self._in_snippet = True
+
+    def handle_endtag(self, tag):
+        if tag == "a" and self._href and self._title:
+            href = html.unescape(self._href)
+            parsed = urllib.parse.urlparse(href)
+            if "duckduckgo.com" in parsed.netloc:
+                href = urllib.parse.parse_qs(parsed.query).get("uddg", [href])[0]
+            self.results.append(Result(" ".join(self._title).strip(), href))
+            self._href, self._in_result, self._in_snippet = None, False, False
+        elif self._in_snippet and tag in {"a", "div"}:
+            if self._snippet_target:
+                self._snippet_target.snippet = " ".join(self._snippet).strip()
+            self._in_snippet = False
+            self._snippet_target = None
+
+    def handle_data(self, data):
+        if self._href and not self._in_snippet:
+            self._title.append(data)
+        elif self._in_snippet:
+            self._snippet.append(data)
+
+
+def search(query: str) -> list[Result]:
+    # Bing's RSS endpoint is structured, compact, and avoids brittle scraping
+    # of a JavaScript search-results page.
+    url = "https://www.bing.com/search?" + urllib.parse.urlencode({"format": "rss", "q": query})
+    try:
+        root = ET.fromstring(request(url))
+    except ET.ParseError as exc:
+        raise RuntimeError("The search provider returned an unreadable response.") from exc
+    results = []
+    for item in root.findall("./channel/item"):
+        title = " ".join((item.findtext("title") or "").split())
+        link = (item.findtext("link") or "").strip()
+        snippet = " ".join(html.unescape(item.findtext("description") or "").split())
+        if title and link:
+            results.append(Result(title, link, snippet))
+    return results
+
+
+class TextParser(HTMLParser):
+    def __init__(self):
+        super().__init__()
+        self.parts: list[str] = []
+        self.skip_depth = 0
+        self.title: list[str] = []
+        self.in_title = False
+
+    def handle_starttag(self, tag, attrs):
+        if tag in SKIP_TAGS:
+            self.skip_depth += 1
+        if tag == "title": self.in_title = True
+        if not self.skip_depth and tag in BLOCK_TAGS:
+            self.parts.append("\n")
+
+    def handle_endtag(self, tag):
+        if tag in SKIP_TAGS and self.skip_depth:
+            self.skip_depth -= 1
+        if tag == "title": self.in_title = False
+        if not self.skip_depth and tag in BLOCK_TAGS:
+            self.parts.append("\n")
+
+    def handle_data(self, data):
+        if self.in_title: self.title.append(data)
+        if not self.skip_depth: self.parts.append(data)
+
+    def text(self) -> str:
+        text = html.unescape("".join(self.parts)).replace("\xa0", " ")
+        text = re.sub(r"[ \t]+", " ", text)
+        text = re.sub(r"\n\s*\n+", "\n\n", text)
+        return text.strip()
+
+
+def fetch_page(url: str) -> tuple[str, str]:
+    parser = TextParser()
+    parser.feed(request(url))
+    return (" ".join(parser.title).strip() or url, parser.text() or "This page contained no readable text.")
+
+
+def clip(window, y: int, x: int, value: str, attr=0):
+    height, width = window.getmaxyx()
+    if 0 <= y < height and x < width:
+        window.addnstr(y, x, value, max(0, width - x - 1), attr)
+
+
+class App:
+    def __init__(self, query: str):
+        self.query, self.results, self.selected, self.offset = query, [], 0, 0
+        self.screen = None
+
+    def run(self):
+        try:
+            self.results = search(self.query)
+        except Exception as exc:
+            self.error(f"Search failed: {exc}")
+            return
+        curses.wrapper(self.results_view)
+
+    def error(self, message):
+        print(message, file=sys.stderr)
+
+    def status(self, message: str):
+        height, _ = self.screen.getmaxyx()
+        self.screen.move(height - 1, 0); self.screen.clrtoeol(); clip(self.screen, height - 1, 0, message, curses.A_REVERSE)
+
+    def results_view(self, screen):
+        self.screen = screen
+        curses.curs_set(0); screen.keypad(True)
+        if curses.has_colors():
+            curses.start_color()
+            curses.use_default_colors()
+            curses.init_pair(1, curses.COLOR_BLACK, curses.COLOR_CYAN)
+        while True:
+            screen.erase(); h, w = screen.getmaxyx(); usable = max(1, (h - 4) // 3)
+            clip(screen, 0, 0, f" Librario — {self.query}", curses.A_BOLD)
+            clip(screen, 1, 0, " ↑/↓ or j/k: move   Enter: open   q: quit", curses.A_DIM)
+            if not self.results:
+                clip(screen, 3, 0, "No results found.")
+            self.offset = min(self.offset, max(0, len(self.results) - usable))
+            for slot, index in enumerate(range(self.offset, min(len(self.results), self.offset + usable))):
+                row = 3 + slot * 3
+                result = self.results[index]
+                selected = index == self.selected
+                attr = curses.color_pair(1) | curses.A_BOLD if selected and curses.has_colors() else (curses.A_REVERSE | curses.A_BOLD if selected else 0)
+                marker = ">" if selected else " "
+                clip(screen, row, 0, f"{marker} {index + 1:2}. {result.title}", attr)
+                clip(screen, row + 1, 4, result.url, attr | curses.A_DIM)
+                if row + 2 < h - 1: clip(screen, row + 2, 4, result.snippet, attr)
+            if self.results:
+                current = self.results[self.selected]
+                self.status(f" > {self.selected + 1}/{len(self.results)} selected: {current.title}")
+            else:
+                self.status(" No results")
+            key = screen.getch()
+            if key in (ord("q"), 27): return
+            if key in (curses.KEY_DOWN, ord("j")) and self.selected < len(self.results) - 1:
+                self.selected += 1
+                if self.selected >= self.offset + usable: self.offset += 1
+            elif key in (curses.KEY_UP, ord("k")) and self.selected > 0:
+                self.selected -= 1
+                if self.selected < self.offset: self.offset -= 1
+            elif key in (10, 13, curses.KEY_ENTER) and self.results:
+                self.page_view(self.results[self.selected])
+
+    def page_view(self, result: Result):
+        self.screen.erase(); self.status(" Fetching page…"); self.screen.refresh()
+        try:
+            title, body = fetch_page(result.url)
+        except Exception as exc:
+            title, body = result.title, f"Could not open this page:\n\n{exc}"
+        scroll = 0
+        while True:
+            h, w = self.screen.getmaxyx(); wrap_width = max(20, w - 2)
+            lines = [line for para in body.splitlines() for line in (textwrap.wrap(para, wrap_width) or [""])]
+            self.screen.erase(); clip(self.screen, 0, 0, f" {title}", curses.A_BOLD); clip(self.screen, 1, 0, f" {result.url}", curses.A_DIM)
+            visible = max(1, h - 4)
+            for row, line in enumerate(lines[scroll:scroll + visible], start=3): clip(self.screen, row, 1, line)
+            self.status(f" ↑/↓ or j/k: scroll   b/Esc: back   q: quit   {scroll + 1}/{max(1, len(lines))}")
+            key = self.screen.getch()
+            if key == ord("q"): raise SystemExit
+            if key in (ord("b"), 27): return
+            if key in (curses.KEY_DOWN, ord("j")): scroll = min(max(0, len(lines) - visible), scroll + 1)
+            if key in (curses.KEY_UP, ord("k")): scroll = max(0, scroll - 1)
+            if key == curses.KEY_NPAGE: scroll = min(max(0, len(lines) - visible), scroll + visible)
+            if key == curses.KEY_PPAGE: scroll = max(0, scroll - visible)
+
+
+def main():
+    parser = argparse.ArgumentParser(prog="librario", description="A keyboard-first text browser.")
+    sub = parser.add_subparsers(dest="command", required=True)
+    search_parser = sub.add_parser("search", help="Search the web in a text interface")
+    search_parser.add_argument("query", help="What to search for")
+    args = parser.parse_args()
+    if args.command == "search": App(args.query).run()
+
+
+if __name__ == "__main__":
+    main()

librario-0.1.0/librario.egg-info/PKG-INFO

@@ -0,0 +1,5 @@
+Metadata-Version: 2.4
+Name: librario
+Version: 0.1.0
+Summary: A small keyboard-first text web browser for the terminal
+Requires-Python: >=3.10

librario-0.1.0/librario.egg-info/SOURCES.txt

@@ -0,0 +1,9 @@
+README.md
+pyproject.toml
+librario/__init__.py
+librario/__main__.py
+librario.egg-info/PKG-INFO
+librario.egg-info/SOURCES.txt
+librario.egg-info/dependency_links.txt
+librario.egg-info/entry_points.txt
+librario.egg-info/top_level.txt

librario-0.1.0/librario.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

librario-0.1.0/librario.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+librario = librario.__main__:main

librario-0.1.0/librario.egg-info/top_level.txt

@@ -0,0 +1 @@
+librario

librario-0.1.0/pyproject.toml

@@ -0,0 +1,15 @@
+[build-system]
+requires = ["setuptools"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "librario"
+version = "0.1.0"
+description = "A small keyboard-first text web browser for the terminal"
+requires-python = ">=3.10"
+
+[project.scripts]
+librario = "librario.__main__:main"
+
+[tool.setuptools]
+packages = ["librario"]

librario-0.1.0/setup.cfg

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