diff options
| author | Eugene Triguba <hello@eugenetriguba.com> | 2026-05-19 01:48:15 +0000 |
|---|---|---|
| committer | Eugene Triguba <hello@eugenetriguba.com> | 2026-05-19 01:48:15 +0000 |
| commit | 466b70b4e31c625185c5f70eb7be13c25c7df421 (patch) | |
| tree | 050d2ac81defb5b0d31a664bea23940a2d751503 /nbs/core.ipynb | |
| download | nb-466b70b4e31c625185c5f70eb7be13c25c7df421.zip | |
Initial Commit
Diffstat (limited to 'nbs/core.ipynb')
| -rw-r--r-- | nbs/core.ipynb | 299 |
1 files changed, 299 insertions, 0 deletions
diff --git a/nbs/core.ipynb b/nbs/core.ipynb new file mode 100644 index 0000000..24e0330 --- /dev/null +++ b/nbs/core.ipynb @@ -0,0 +1,299 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "id": "aed9daa9-f05d-4e25-b9a5-a74d0211ef6f", + "metadata": {}, + "outputs": [], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "596de171-5567-43c1-98ce-66eccc28bbe9", + "metadata": {}, + "outputs": [], + "source": [ + "#| default_exp: core" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6a2cc7f8-6c65-4a7c-890c-3cf9d1cd314e", + "metadata": {}, + "outputs": [], + "source": [ + "import inspect\n", + "from typing import Callable\n", + "from nb import test" + ] + }, + { + "cell_type": "markdown", + "id": "8485c16a", + "metadata": {}, + "source": [ + "# Core\n", + "> Fundamental Utilities" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c4875cc0-2d87-4c87-8789-7dc950be06c6", + "metadata": {}, + "outputs": [], + "source": [ + "#| export\n", + "def callable_name(c: Callable) -> str:\n", + " \"Get the name of the callable `c`.\"\n", + " return getattr(c, '__name__', c.__class__.__name__)" + ] + }, + { + "cell_type": "markdown", + "id": "406d605d", + "metadata": {}, + "source": [ + "This works for any function:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0e9c39c5", + "metadata": {}, + "outputs": [], + "source": [ + "assert callable_name(max) == \"max\"" + ] + }, + { + "cell_type": "markdown", + "id": "d66b2d42", + "metadata": {}, + "source": [ + "And for any classes:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "056cb776", + "metadata": {}, + "outputs": [], + "source": [ + "class _A: pass\n", + "assert callable_name(_A) == \"_A\"" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f2c70dd3", + "metadata": {}, + "outputs": [], + "source": [ + "#| export\n", + "def pubattr(o):\n", + " \"Retrieve the public attributes of the object `o`.\"\n", + " return [a for a in dir(o) if not a.startswith('_')]" + ] + }, + { + "cell_type": "markdown", + "id": "53cb2bd5", + "metadata": {}, + "source": [ + "`pubattr` will hide any attribute on an object if it starts with an underscore." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ac30af03", + "metadata": {}, + "outputs": [], + "source": [ + "_A.print = print\n", + "_A._private_print = print\n", + "_A.__python_internal__ = print\n", + "assert pubattr(_A) == [\"print\"]" + ] + }, + { + "cell_type": "markdown", + "id": "f892f4f1", + "metadata": {}, + "source": [ + "## Class Definitions" + ] + }, + { + "cell_type": "markdown", + "id": "4008335c", + "metadata": {}, + "source": [ + "Iterative notebook-driven development makes class definitions tricky. Typically, you'd write a clas definition in one monolithic block, which leaves no room for prose or incremental execution. Inspired by the wonderful [fastcore](https://github.com/AnswerDotAI/fastcore) library, we'll add `patch` and `patch_to` function to enable piecemeal class definition via monkeypatching." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "78d61a07", + "metadata": {}, + "outputs": [], + "source": [ + "#| export\n", + "def patch_to(o: object) -> Callable:\n", + " \"Decorator that takes in a object and attaches the decorated function onto it.\"\n", + " def inner(fn: Callable) -> Callable:\n", + " nm = callable_name(fn)\n", + " setattr(o, nm, fn)\n", + " return fn\n", + " return inner" + ] + }, + { + "cell_type": "markdown", + "id": "0d4bb2e6", + "metadata": {}, + "source": [ + "Let's try it out. We'll create a dummy class named `_T`." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c67a3c29", + "metadata": {}, + "outputs": [], + "source": [ + "class _T: pass" + ] + }, + { + "cell_type": "markdown", + "id": "b7d0a482", + "metadata": {}, + "source": [ + "Now, we'll attach on a function to `_T` in a separate code cell." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "42580f8b", + "metadata": {}, + "outputs": [], + "source": [ + "#| export\n", + "@patch_to(_T)\n", + "def say_hello(self: _T, name: str) -> str:\n", + " return f'Hello, {name}'" + ] + }, + { + "cell_type": "markdown", + "id": "0edc152b", + "metadata": {}, + "source": [ + "`_T` should have a `say_hello` function on it. Let's confirm." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "404bd72f", + "metadata": {}, + "outputs": [], + "source": [ + "_t = _T()\n", + "test.equal(_t.say_hello('eugene'), 'Hello, eugene')" + ] + }, + { + "cell_type": "markdown", + "id": "4acd774c", + "metadata": {}, + "source": [ + "That's neat and all but notice that `self: _T` and `@patch_to(_T)` are both two different ways to provide the same sort of information (attach this method onto `_T`).\n", + "\n", + "What if we could look at the type hint to determine which object to patch?\n", + "\n", + "We already have `patch_to`, so let's create a `patch` decorator. All we'll need to do inside `patch` is find the object to patch and call `patch_to`. If we assume the object we're patching will always be called `self` i.e. patching a class, then this should be easy-peasy." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4eb650ab", + "metadata": {}, + "outputs": [], + "source": [ + "#| export\n", + "def patch(fn: Callable) -> Callable:\n", + " \"Decorator to patch the object of the type-hinted 'self' argument of `fn` with `fn`.\"\n", + " self = inspect.get_annotations(fn)['self']\n", + " return patch_to(self)(fn)" + ] + }, + { + "cell_type": "markdown", + "id": "97378af3", + "metadata": {}, + "source": [ + "Let's see if we can try `patch` out now with our dummy `_T` class." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "601e27f2", + "metadata": {}, + "outputs": [], + "source": [ + "@patch\n", + "def say_goodbye(self: _T, name: str) -> str:\n", + " return f'Goodbye, {name}'" + ] + }, + { + "cell_type": "markdown", + "id": "d001522d", + "metadata": {}, + "source": [ + "Can our `_t` object now say goodbye?" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6aa1ffbc", + "metadata": {}, + "outputs": [], + "source": [ + "test.equal(_t.say_goodbye('eugene'), 'Goodbye, eugene')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "12b62cf8-2193-4f03-b80a-46304d73896e", + "metadata": {}, + "outputs": [], + "source": [ + "#| noexport\n", + "import nb.export; nb.export.export_nb('core.ipynb', src_dir='../nb/')" + ] + } + ], + "metadata": {}, + "nbformat": 4, + "nbformat_minor": 5 +} |