nbcat 0.1.0__tar.gz → 0.8.2__tar.gz

{nbcat-0.1.0 → nbcat-0.8.2}/Makefile

@@ -33,9 +33,10 @@ deploy: build ## Publish package
 	$(UV) publish --token $(token)
 
 lint: ## Run linter over code base and auto resole minor issues
-	$(RUFF) check --fix
+	$(RUFF) check
 
 format: ## Format the source code according to defined coding style
+	$(RUFF) check --fix-only
 	$(RUFF) format
 
 clean: ## Remove all file artifacts

{nbcat-0.1.0 → nbcat-0.8.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nbcat
-Version: 0.1.0
+Version: 0.8.2
 Summary: cat for jupyter notebooks
 Project-URL: Homepage, https://github.com/akopdev/nbcat
 Project-URL: Repository, https://github.com/akopdev/nbcat
@@ -29,15 +29,14 @@ License: MIT License
         SOFTWARE.
 License-File: LICENSE
 Requires-Python: >=3.10
-Requires-Dist: aiohttp
 Requires-Dist: pydantic
+Requires-Dist: requests
 Requires-Dist: rich
 Provides-Extra: dev
-Requires-Dist: aioresponses; extra == 'dev'
 Requires-Dist: pytest; extra == 'dev'
-Requires-Dist: pytest-asyncio; extra == 'dev'
 Requires-Dist: pytest-cov; extra == 'dev'
 Requires-Dist: pytest-mock; extra == 'dev'
+Requires-Dist: pytest-responses; extra == 'dev'
 Requires-Dist: ruff; extra == 'dev'
 Description-Content-Type: text/markdown
 

{nbcat-0.1.0 → nbcat-0.8.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "nbcat"
-version = "0.1.0"
+version = "0.8.2"
 description = "cat for jupyter notebooks"
 authors = [
     { name = "Akop Kesheshyan", email = "devnull@akop.dev" }
@@ -12,17 +12,16 @@ license = {file = "LICENSE"}
 readme = "README.md"
 requires-python = ">=3.10"
 dependencies = [
-    "aiohttp",
+    "requests",
     "pydantic",
     "rich",
 ]
 
 [project.optional-dependencies]
 dev = [
-    "aioresponses",
     "ruff",
     "pytest",
-    "pytest-asyncio",
+    "pytest-responses",
     "pytest-mock",
     "pytest-cov",
 ]
@@ -32,7 +31,7 @@ Homepage = "https://github.com/akopdev/nbcat"
 Repository = "https://github.com/akopdev/nbcat"
 
 [project.scripts]
-nbcat = "nbcat.cli:main"
+nbcat = "nbcat.main:main"
 
 [pytest]
 mock_use_standalone_module = true

nbcat-0.8.2/src/nbcat/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.8.2"

nbcat-0.8.2/src/nbcat/enums.py

@@ -0,0 +1,16 @@
+from enum import Enum
+
+
+class CellType(str, Enum):
+    MARKDOWN = "markdown"
+    CODE = "code"
+    RAW = "raw"
+    HEADING = "heading"
+
+
+class OutputType(str, Enum):
+    STREAM = "stream"
+    DISPLAY_DATA = "display_data"
+    EXECUTE_RESULT = "execute_result"
+    ERROR = "error"
+    PYOUT = "pyout"

nbcat-0.8.2/src/nbcat/exceptions.py

@@ -0,0 +1,10 @@
+class InvalidNotebookFormatError(Exception):
+    """Raised when the file is not a valid .ipynb or URL."""
+
+
+class NotebookNotFoundError(Exception):
+    """Raised when the file or URL is not reachable."""
+
+
+class UnsupportedNotebookTypeError(Exception):
+    """Raised when the file exists but is not a .ipynb document."""

nbcat-0.8.2/src/nbcat/main.py

@@ -0,0 +1,168 @@
+import argparse
+import sys
+from pathlib import Path
+
+import requests
+from pydantic import ValidationError
+from rich import box
+from rich.console import Console, RenderableType
+from rich.markdown import Markdown
+from rich.panel import Panel
+from rich.syntax import Syntax
+from rich.table import Table
+from rich.text import Text
+
+from . import __version__
+from .enums import CellType
+from .exceptions import (
+    InvalidNotebookFormatError,
+    NotebookNotFoundError,
+    UnsupportedNotebookTypeError,
+)
+from .schemas import Cell, Notebook
+
+console = Console()
+
+
+def read_notebook(fp: str) -> Notebook:
+    """
+    Load and parse a Jupyter notebook from a local file or remote URL.
+
+    Args:
+        fp (str): Path to a local `.ipynb` file or a URL pointing to a notebook.
+
+    Returns
+    -------
+        Notebook: A validated Notebook instance parsed from JSON content.
+
+    Raises
+    ------
+        NotebookNotFoundError: If the file path or URL is unreachable.
+        UnsupportedNotebookTypeError: If the file exists but isn't a `.ipynb` file.
+        InvalidNotebookFormatError: If the file content is invalid JSON or doesn't match schema.
+    """
+    path = Path(fp)
+    if path.exists():
+        if path.suffix != ".ipynb":
+            raise UnsupportedNotebookTypeError(f"Unsupported file type: {path.suffix}")
+        content = path.read_text(encoding="utf-8")
+    elif fp.startswith("http://") or fp.startswith("https://"):
+        try:
+            with requests.Session() as req:
+                res = req.get(fp, timeout=5)
+                res.raise_for_status()
+                content = res.text
+        except requests.RequestException as e:
+            raise NotebookNotFoundError(f"Unable to fetch remote notebook: {e}")
+    else:
+        raise NotebookNotFoundError(f"Notebook not found: {fp}")
+    try:
+        return Notebook.model_validate_json(content)
+    except ValidationError as e:
+        raise InvalidNotebookFormatError(f"Invalid notebook: {e}")
+
+
+def render_cell(cell: Cell) -> list[tuple[str | None, RenderableType]]:
+    """
+    Render the content of a notebook cell for display.
+
+    Depending on the cell type, the function returns a formatted object
+    that can be rendered in a terminal using the `rich` library.
+
+    Args:
+        cell (Cell): The notebook cell containing source content and type metadata.
+
+    Returns
+    -------
+        Markdown | Panel | Text | None: A Rich renderable for Markdown, Code, or Raw cells.
+        Returns None if the cell type is unrecognized or unsupported.
+    """
+
+    def _render_markdown(input: str) -> Markdown:
+        return Markdown(input)
+
+    def _render_code(input: str) -> Panel:
+        return Panel(Syntax(input, "python", line_numbers=True, theme="ansi_dark"), box=box.SQUARE)
+
+    def _render_raw(input: str) -> Text:
+        return Text(input)
+
+    def _render_heading(input: str) -> Text:
+        return Text(input)
+
+    RENDERERS = {
+        CellType.MARKDOWN: _render_markdown,
+        CellType.CODE: _render_code,
+        CellType.RAW: _render_raw,
+        CellType.HEADING: _render_heading,
+    }
+
+    rows: list[tuple[str | None, RenderableType]] = []
+    renderer = RENDERERS.get(cell.cell_type)
+    source = renderer(cell.input) if renderer else None
+    if source:
+        label = f"[green][{cell.execution_count}][/]:" if cell.execution_count else None
+        rows.append(
+            (
+                label,
+                source,
+            )
+        )
+
+    for o in cell.outputs:
+        if o.output:
+            label = f"[blue][{o.execution_count}][/]:" if o.execution_count else None
+            rows.append(
+                (
+                    label,
+                    o.output,
+                )
+            )
+    return rows
+
+
+def print_notebook(nb: Notebook):
+    """
+    Print the notebook to the console with formatted cell inputs and outputs.
+
+    Args:
+        nb (Notebook): A Notebook object containing a list of cells.
+    """
+    if not nb.cells:
+        console.print("[bold red]Notebook contains no cells.")
+        return
+
+    layout = Table.grid(padding=1)
+    layout.add_column(no_wrap=True, width=6)
+    layout.add_column()
+
+    for cell in nb.cells:
+        for label, content in render_cell(cell):
+            layout.add_row(label, content)
+
+    console.print(layout)
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="cat for Jupyter Notebooks",
+        argument_default=argparse.SUPPRESS,
+    )
+    parser.add_argument("file", help="Path or URL to a .ipynb notebook", type=str)
+    parser.add_argument(
+        "--version",
+        help="print version information and quite",
+        action="version",
+        version=__version__,
+    )
+
+    try:
+        args = parser.parse_args()
+        notebook = read_notebook(args.file)
+        print_notebook(notebook)
+    except Exception as e:
+        sys.exit(f"nbcat: {e}")
+
+
+if __name__ == "__main__":
+    main()

nbcat-0.8.2/src/nbcat/schemas.py

@@ -0,0 +1,94 @@
+from typing import Any
+
+from pydantic import BaseModel, computed_field, model_validator
+
+from .enums import CellType, OutputType
+from .exceptions import InvalidNotebookFormatError
+
+
+class BaseOutput(BaseModel):
+    output_type: OutputType
+    execution_count: int | None = None
+
+
+class StreamOutput(BaseOutput):
+    text: list[str] | str
+
+    @computed_field
+    @property
+    def output(self) -> str:
+        if isinstance(self.text, list):
+            return "".join(self.text)
+        return self.text
+
+
+class DisplayDataOutput(BaseOutput):
+    data: dict[str, Any]
+
+    @computed_field
+    @property
+    def output(self) -> str:
+        # TODO: add support for rich display outputs
+        return ""
+
+
+class ErrorOutput(BaseOutput):
+    ename: str
+    evalue: str
+    traceback: list[str]
+
+    @computed_field
+    @property
+    def output(self) -> str:
+        return "\n".join(self.traceback)
+
+
+class PyoutDataOutput(BaseOutput):
+    text: list[str]
+
+    @computed_field
+    @property
+    def output(self) -> str:
+        return "\n".join(self.text)
+
+
+class Cell(BaseModel):
+    cell_type: CellType
+    source: list[str] | str
+    level: int | None = None
+    execution_count: int | None = None
+    outputs: list[StreamOutput | DisplayDataOutput | ErrorOutput | PyoutDataOutput] = []
+
+    @model_validator(mode="before")
+    @classmethod
+    def handle_format_versions(cls, data: dict[str, Any]) -> dict[str, Any]:
+        if data.get("input"):
+            data["source"] = data["input"]
+        return data
+
+    @computed_field
+    @property
+    def input(self) -> str:
+        if self.cell_type == CellType.HEADING and self.level is not None:
+            return f"{'#' * self.level} {self.source}"
+
+        if isinstance(self.source, list):
+            return "".join(self.source)
+
+        return self.source
+
+
+class Notebook(BaseModel):
+    cells: list[Cell] = []
+    nbformat: int
+
+    @model_validator(mode="before")
+    @classmethod
+    def handle_format_versions(cls, data: dict[str, Any]) -> dict[str, Any]:
+        if data.get("worksheets"):
+            try:
+                data["cells"] = data.get("worksheets")[0].get("cells", [])
+            except (KeyError, IndexError, TypeError) as e:
+                print(e)
+                raise InvalidNotebookFormatError(f"Invalid v3 notebook structure: {e}")
+        return data