nbcat 0.1.0__py3-none-any.whl → 0.8.2__py3-none-any.whl

nbcat/__init__.py

@@ -1 +1 @@
-__version__ = "0.1.0"
+__version__ = "0.8.2"

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/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/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/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

{nbcat-0.1.0.dist-info → nbcat-0.8.2.dist-info}/METADATA

@@ -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.8.2.dist-info/RECORD

@@ -0,0 +1,11 @@
+nbcat/__init__.py,sha256=B7GiO0rd49YwtLYjvPg4lmCZEDlMTonslQKdSImaMJk,22
+nbcat/enums.py,sha256=ZsuOwYLF0D4PVwSkS74LwoXY0y0DkeBToLBWnmiS97Y,300
+nbcat/exceptions.py,sha256=Ho7LQz9K70VtIMDNtAwuAtGmb-lFKxGxSj7MN3-EpDA,321
+nbcat/main.py,sha256=5OawByiWMAX6LX25-Net8zZDE4_0m7a8GOKMIN-UjJc,4919
+nbcat/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+nbcat/schemas.py,sha256=F5Wl0ZWa5j8RK4H98nDJm69h3oecEuP6wu62823Cxyg,2340
+nbcat-0.8.2.dist-info/METADATA,sha256=4yOzFXgN_yzTC0X8ItssABMyzvNNPVSp1KBXBeb-hi8,3385
+nbcat-0.8.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+nbcat-0.8.2.dist-info/entry_points.txt,sha256=io_GRDsecAkYuCZALsjyea3VBq91VCoSznqlZEAJshY,42
+nbcat-0.8.2.dist-info/licenses/LICENSE,sha256=7GjUnahXdd5opdvlpJdb1BisLbiXt2iOFhzIUduhdkE,1072
+nbcat-0.8.2.dist-info/RECORD,,

nbcat-0.8.2.dist-info/entry_points.txt

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

nbcat/cli.py

@@ -1,73 +0,0 @@
-import argparse
-import asyncio
-import sys
-
-from pydantic import ValidationError
-
-from . import __version__
-from .settings import Settings
-
-
-async def do_sample_command_1():
-    """Run used defined command 1."""
-
-
-async def do_sample_command_2():
-    """Run user defined command 2."""
-
-
-def main():
-    parser = argparse.ArgumentParser(
-        description="cat for jupyter notebooks",
-        argument_default=argparse.SUPPRESS,
-    )
-    parser.add_argument(
-        "--list_field", help="Example of multi value list separated by comma.", type=str
-    )
-    parser.add_argument(
-        "--version",
-        help="Print version information and quite",
-        action="version",
-        version=__version__,
-    )
-
-    # Commands
-    commands = parser.add_subparsers(title="Commands", dest="command")
-
-    # Sample command 1
-    sample_command_1 = commands.add_parser(
-        "sample_command_1",
-        help="Sample command description.",
-        argument_default=argparse.SUPPRESS,
-    )
-
-    sample_command_1.set_defaults(func=do_sample_command_1)
-
-    # Sample command 2
-    sample_command_2 = commands.add_parser(
-        "sample_command_2",
-        help="Sample command description.",
-        argument_default=argparse.SUPPRESS,
-    )
-
-    sample_command_2.set_defaults(func=do_sample_command_2)
-
-    try:
-        args = parser.parse_args()
-        settings = Settings(**vars(args))
-    except ValidationError as e:
-        error = e.errors(include_url=False, include_context=False)[0]
-        sys.exit(
-            "Wrong argument value passed ({}): {}".format(
-                error.get("loc", ("system",))[0], error.get("msg")
-            )
-        )
-
-    if args.command:
-        asyncio.run(args.func(settings))
-    else:
-        parser.print_help()
-
-
-if __name__ == "__main__":
-    main()

nbcat/nbcat.py

@@ -1,22 +0,0 @@
-from datetime import datetime
-
-import aiohttp
-
-
-async def my_func(name) -> str:
-    """Get message from remote server."""
-    async with aiohttp.ClientSession() as session:
-        async with session.get("https://example.com/api.json", params={"name": name}) as response:
-            data = await response.json()
-            return data["message"]
-
-
-def now() -> datetime:
-    """Ready to mock method for date extraction."""
-    return datetime.now()
-
-
-def get_time() -> str:
-    """Return today's date."""
-    date = now()
-    return f"Today is {date.strftime('%A, %B %d, %Y')}"

nbcat/settings.py

@@ -1,16 +0,0 @@
-from pydantic import BaseModel, model_validator
-
-
-class Settings(BaseModel):
-    """Validates cli arguments."""
-
-    field: str | None = None
-    list_field: list[str] = []
-    bool_field: bool = False
-
-    @model_validator(mode="before")
-    def parse_list_field(values: dict):
-        """You can pass multiple values as a comma separated string."""
-        if isinstance(values.get("list_field"), str):
-            values["list_field"] = values.get("list_field").split(",")
-        return values

nbcat-0.1.0.dist-info/RECORD

@@ -1,10 +0,0 @@
-nbcat/__init__.py,sha256=kUR5RAFc7HCeiqdlX36dZOHkUI5wI6V_43RpEcD8b-0,22
-nbcat/cli.py,sha256=BeijbCAe1J3s7UgeKW_hdRdXvkg1jo6XaT4aPGKz-Yc,1802
-nbcat/nbcat.py,sha256=eWgwOGCnOK6xQ1qC8Ku2vmQgPvA5Nx6mfdM8Ca3vU6w,580
-nbcat/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-nbcat/settings.py,sha256=I6sGyVidPjW_76zq9mefnS2-vzRUKL87jSPluPe_SwQ,498
-nbcat-0.1.0.dist-info/METADATA,sha256=Woo2Z2dx6A8vMsXE4k0cpYuTJ_llb1UVOqG8ENoGitE,3426
-nbcat-0.1.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-nbcat-0.1.0.dist-info/entry_points.txt,sha256=a_byTgZyR_et6CxNcKCQlw1EHisUaIFRBRLh0tUQs2U,41
-nbcat-0.1.0.dist-info/licenses/LICENSE,sha256=7GjUnahXdd5opdvlpJdb1BisLbiXt2iOFhzIUduhdkE,1072
-nbcat-0.1.0.dist-info/RECORD,,

nbcat-0.1.0.dist-info/entry_points.txt

@@ -1,2 +0,0 @@
-[console_scripts]
-nbcat = nbcat.cli:main