pixel-drawing-pad 0.2.0__tar.gz

pixel_drawing_pad-0.2.0/.gitignore

@@ -0,0 +1,13 @@
+__pycache__/
+*.pyc
+*.pyo
+*.egg-info/
+dist/
+build/
+.ruff_cache/
+.pytest_cache/
+.venv/
+*.egg
+.uv/
+.virtual_documents/
+.ipynb_checkpoints/

pixel_drawing_pad-0.2.0/Makefile

@@ -0,0 +1,54 @@
+.DEFAULT_GOAL := help
+PACKAGE_NAME := pixel_drawing_pad
+
+.PHONY: help
+help: ## Show this help
+	@grep -E '^[a-zA-Z_-]+:.*?## .*$$' $(MAKEFILE_LIST) | sort | awk 'BEGIN {FS = ":.*?## "}; {printf "\033[36m%-20s\033[0m %s\n", $$1, $$2}'
+
+.PHONY: install
+install: ## Install package in editable mode with dev dependencies
+	uv pip install -e ".[dev]"
+
+.PHONY: sync
+sync: ## Sync environment from pyproject.toml
+	uv sync --extra dev
+
+.PHONY: lint
+lint: ## Run ruff linter and formatter check
+	uv run ruff check src/ tests/
+	uv run ruff format --check src/ tests/
+
+.PHONY: format
+format: ## Auto-format code with ruff
+	uv run ruff check --fix src/ tests/
+	uv run ruff format src/ tests/
+
+.PHONY: test
+test: ## Run tests with pytest
+	uv run pytest
+
+.PHONY: test-cov
+test-cov: ## Run tests with coverage
+	uv run pytest --cov=$(PACKAGE_NAME) --cov-report=term-missing
+
+.PHONY: clean
+clean: ## Remove build artifacts
+	rm -rf dist/ build/ *.egg-info src/*.egg-info
+	find . -type d -name __pycache__ -exec rm -rf {} + 2>/dev/null || true
+	find . -type f -name '*.pyc' -delete 2>/dev/null || true
+
+.PHONY: dist
+dist: clean ## Build source and wheel package
+	uv build
+	ls -l dist/
+
+.PHONY: release
+release: dist ## Build and upload to PyPI
+	uv publish --username __token__ --password "$$(python3 -c "import configparser; c=configparser.ConfigParser(); c.read('$$HOME/.pypirc'); print(c['pypi']['password'])")"
+
+.PHONY: release-test
+release-test: dist ## Build and upload to Test PyPI
+	uv publish --publish-url https://test.pypi.org/legacy/ --username __token__ --password "$$(python3 -c "import configparser; c=configparser.ConfigParser(); c.read('$$HOME/.pypirc'); print(c['test']['password'])")"
+
+.PHONY: check
+check: lint test ## Run lint + tests

pixel_drawing_pad-0.2.0/PKG-INFO

@@ -0,0 +1,62 @@
+Metadata-Version: 2.4
+Name: pixel-drawing-pad
+Version: 0.2.0
+Summary: Interactive pixel drawing pad widget for Jupyter notebooks
+Project-URL: Homepage, https://github.com/nikadon/pixel-drawig-pad
+Project-URL: Repository, https://github.com/nikadon/pixel-drawig-pad
+Project-URL: Issues, https://github.com/nikadon/pixel-drawig-pad/issues
+Author: JN, KR
+License-Expression: GPL-3.0-or-later
+Keywords: drawing,jupyter,machine-learning,mnist,pixel,widget
+Classifier: Development Status :: 3 - Alpha
+Classifier: Framework :: Jupyter
+Classifier: Framework :: Jupyter :: JupyterLab
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
+Classifier: Programming Language :: Python :: 3
+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 :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Scientific/Engineering :: Visualization
+Requires-Python: >=3.10
+Requires-Dist: anywidget>=0.9.0
+Requires-Dist: numpy>=1.24.0
+Provides-Extra: dev
+Requires-Dist: pytest-cov>=5.0; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: ruff>=0.4.0; extra == 'dev'
+Description-Content-Type: text/plain
+
+#+title: Pixel Drawing Pad
+
+Interactive pixel drawing pad widget for Jupyter notebooks.
+
+* Installation
+
+#+begin_src sh
+uv pip install pixel-drawing-pad
+#+end_src
+
+* Usage
+
+#+begin_src python
+from pixel_drawing_pad import DrawingPad
+
+pad = DrawingPad(pix_zoom=36)
+pad  # display in notebook cell
+
+# Access the drawn data as a numpy array
+data = pad.get_data()
+
+# Manipulate
+pad.rot90()
+pad.fliplr()
+pad.checkerboard()
+pad.swap()
+#+end_src
+
+* Google Colab
+
+Works out of the box — just =pip install pixel-drawing-pad= in a Colab cell.

pixel_drawing_pad-0.2.0/README.org

@@ -0,0 +1,31 @@
+#+title: Pixel Drawing Pad
+
+Interactive pixel drawing pad widget for Jupyter notebooks.
+
+* Installation
+
+#+begin_src sh
+uv pip install pixel-drawing-pad
+#+end_src
+
+* Usage
+
+#+begin_src python
+from pixel_drawing_pad import DrawingPad
+
+pad = DrawingPad(pix_zoom=36)
+pad  # display in notebook cell
+
+# Access the drawn data as a numpy array
+data = pad.get_data()
+
+# Manipulate
+pad.rot90()
+pad.fliplr()
+pad.checkerboard()
+pad.swap()
+#+end_src
+
+* Google Colab
+
+Works out of the box — just =pip install pixel-drawing-pad= in a Colab cell.

pixel_drawing_pad-0.2.0/example.ipynb

@@ -0,0 +1,548 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Pixel Drawing Pad — Examples\n",
+    "\n",
+    "Interactive pixel drawing widget for Jupyter notebooks.\n",
+    "\n",
+    "## Installation\n",
+    "\n",
+    "```sh\n",
+    "pip install pixel-drawing-pad\n",
+    "# or\n",
+    "uv pip install pixel-drawing-pad\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 52,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Uncomment to install in Colab:\n",
+    "# !pip install pixel-drawing-pad scikit-learn"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 1. Basic Usage"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 54,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "e7808b3868e042d0a6d92f8d3b21eb91",
+       "version_major": 2,
+       "version_minor": 1
+      },
+      "text/plain": [
+       "<pixel_drawing_pad.widget.DrawingPad object at 0x78ad73610f50>"
+      ]
+     },
+     "execution_count": 54,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from pixel_drawing_pad import DrawingPad\n",
+    "\n",
+    "pad = DrawingPad(pix_zoom=44)\n",
+    "pad"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 55,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Shape: (7, 7)\n",
+      "Unique values: [0. 1.]\n",
+      "[[1. 1. 0. 0. 0. 0. 0.]\n",
+      " [1. 0. 0. 1. 0. 0. 0.]\n",
+      " [1. 0. 1. 1. 1. 0. 0.]\n",
+      " [0. 0. 0. 1. 0. 0. 0.]\n",
+      " [0. 0. 1. 1. 1. 0. 0.]\n",
+      " [0. 0. 0. 1. 0. 0. 0.]\n",
+      " [0. 0. 0. 0. 0. 0. 0.]]\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Access the drawn data as a numpy array\n",
+    "import numpy as np\n",
+    "\n",
+    "data = pad.get_data()\n",
+    "print(f\"Shape: {data.shape}\")\n",
+    "print(f\"Unique values: {np.unique(data)}\")\n",
+    "print(data)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 2. Manipulations"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 56,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "4a3e54232921449291e984cdb3db3d6f",
+       "version_major": 2,
+       "version_minor": 1
+      },
+      "text/plain": [
+       "<pixel_drawing_pad.widget.DrawingPad object at 0x78ad733326d0>"
+      ]
+     },
+     "execution_count": 56,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "pad2 = DrawingPad(pix_zoom=36)\n",
+    "pad2"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 58,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Rotate 90 degrees counter-clockwise\n",
+    "pad2.rot90()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 59,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Flip horizontally / vertically\n",
+    "pad2.test()  # reset to default pattern\n",
+    "pad2.fliplr()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 60,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "pad2.test()\n",
+    "pad2.flipud()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 62,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Transpose\n",
+    "pad2.test()\n",
+    "pad2.transpose()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 63,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Roll (shift) pixels\n",
+    "pad2.test()\n",
+    "pad2.roll(x=2, y=0)  # shift right by 2"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 64,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Swap 0s and 1s\n",
+    "pad2.test()\n",
+    "pad2.swap()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 65,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Checkerboard pattern\n",
+    "pad2.checkerboard(8, 8)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 66,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Add noise\n",
+    "pad2.test()\n",
+    "pad2.noisify(noise_value=1, noise_threshold=0.90)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 67,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "4a3e54232921449291e984cdb3db3d6f",
+       "version_major": 2,
+       "version_minor": 1
+      },
+      "text/plain": [
+       "<pixel_drawing_pad.widget.DrawingPad object at 0x78ad733326d0>"
+      ]
+     },
+     "execution_count": 67,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Clear / clean canvas\n",
+    "pad2.clean(8, 9, val=0)  # 10x10 grid filled with 0\n",
+    "pad2"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 3. Custom data\n",
+    "\n",
+    "You can initialize the pad with any 2D numpy array."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 40,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "f7267d4590f94ef18a27e0047a708a1e",
+       "version_major": 2,
+       "version_minor": 1
+      },
+      "text/plain": [
+       "<pixel_drawing_pad.widget.DrawingPad object at 0x78ad737272f0>"
+      ]
+     },
+     "execution_count": 40,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "custom_data = np.array( [ \n",
+    "    [ 0, 1, 1, 0, 0, 0, 1, 1, 0, ],\n",
+    "    [ 1, 1, 1, 1, 0, 1, 1, 1, 1, ],\n",
+    "    [ 1, 1, 1, 1, 1, 1, 1, 1, 1, ],\n",
+    "    [ 1, 1, 1, 1, 1, 1, 1, 1, 1, ],\n",
+    "    [ 0, 1, 1, 1, 1, 1, 1, 1, 0, ],\n",
+    "    [ 0, 0, 1, 1, 1, 1, 1, 0, 0, ],\n",
+    "    [ 0, 0, 0, 1, 1, 1, 0, 0, 0, ],\n",
+    "    [ 0, 0, 0, 0, 1, 0, 0, 0, 0, ],\n",
+    "], dtype=np.float32)\n",
+    "\n",
+    "pad3 = DrawingPad(pix_zoom=48, data=custom_data)\n",
+    "pad3"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 4. Extra controls with ipywidgets\n",
+    "\n",
+    "Combine the drawing pad with ipywidgets buttons for a richer UI."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 68,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "cf01988dddba4339b233af55bc6b2a61",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "HBox(children=(<pixel_drawing_pad.widget.DrawingPad object at 0x78ad737bf800>, VBox(children=(HBox(children=(B…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "from IPython.display import display\n",
+    "from ipywidgets import Button, HBox, VBox, Layout\n",
+    "\n",
+    "pad4 = DrawingPad(pix_zoom=36)\n",
+    "\n",
+    "btn_specs = [\n",
+    "    # (label, tooltip, callback)\n",
+    "    (\"↺\",  \"Rotate CCW\",       lambda b: pad4.rot90()),\n",
+    "    (\"▲\",  \"Roll up\",          lambda b: pad4.roll(0, -1)),\n",
+    "    (\"⬕\",  \"Swap 0/1\",         lambda b: pad4.swap()),\n",
+    "    (\"⬌\",  \"Flip left/right\",  lambda b: pad4.fliplr()),\n",
+    "    (\"⬍\",  \"Flip up/down\",     lambda b: pad4.flipud()),\n",
+    "    (\"T\",  \"Transpose\",        lambda b: pad4.transpose()),\n",
+    "    (\"□\",  \"Clean 0\",          lambda b: pad4.clean(val=0)),\n",
+    "    (\"◄\",  \"Roll left\",        lambda b: pad4.roll(-1, 0)),\n",
+    "    (\"▼\",  \"Roll down\",        lambda b: pad4.roll(0, 1)),\n",
+    "    (\"►\",  \"Roll right\",       lambda b: pad4.roll(1, 0)),\n",
+    "    (\"n0\", \"Add 0 noise\",      lambda b: pad4.noisify(noise_value=0)),\n",
+    "    (\"n1\", \"Add 1 noise\",      lambda b: pad4.noisify(noise_value=1)),\n",
+    "    (\"R\",  \"Reset\",            lambda b: pad4.test()),\n",
+    "    (\"■\",  \"Clean 1\",          lambda b: pad4.clean(val=1)),\n",
+    "]\n",
+    "\n",
+    "btn_layout = Layout(width=\"48px\", height=\"32px\")\n",
+    "buttons = [Button(description=lbl, tooltip=tip, layout=btn_layout) for lbl, tip, _ in btn_specs]\n",
+    "for btn, (_, _, cb) in zip(buttons, btn_specs):\n",
+    "    btn.on_click(cb)\n",
+    "\n",
+    "controls = VBox([\n",
+    "    HBox(buttons[:7]),\n",
+    "    HBox(buttons[7:]),\n",
+    "])\n",
+    "\n",
+    "display(HBox([pad4, controls]))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "---\n",
+    "\n",
+    "## 5. MNIST: Train a classifier and predict hand-drawn digits\n",
+    "\n",
+    "Draw a digit on the pad and classify it using a model trained on MNIST.\n",
+    "\n",
+    "Requires `scikit-learn`:\n",
+    "```sh\n",
+    "pip install scikit-learn\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from sklearn.datasets import load_digits\n",
+    "from sklearn.ensemble import RandomForestClassifier\n",
+    "from sklearn.model_selection import train_test_split\n",
+    "from sklearn.metrics import accuracy_score\n",
+    "\n",
+    "# Load the 8x8 MNIST-like digits dataset\n",
+    "digits = load_digits()\n",
+    "X, y = digits.data, digits.target\n",
+    "\n",
+    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)\n",
+    "\n",
+    "clf = RandomForestClassifier(n_estimators=100, random_state=42)\n",
+    "clf.fit(X_train, y_train)\n",
+    "\n",
+    "acc = accuracy_score(y_test, clf.predict(X_test))\n",
+    "print(f\"Test accuracy: {acc:.3f}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 5a. Visualize some training digits"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "fig, axes = plt.subplots(2, 5, figsize=(10, 4))\n",
+    "for ax, img, label in zip(axes.ravel(), digits.images[:10], digits.target[:10]):\n",
+    "    ax.imshow(img, cmap=\"gray_r\", interpolation=\"nearest\")\n",
+    "    ax.set_title(f\"Label: {label}\")\n",
+    "    ax.axis(\"off\")\n",
+    "plt.suptitle(\"sklearn digits dataset (8x8)\")\n",
+    "plt.tight_layout()\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 5b. Draw a digit on the 8x8 pad\n",
+    "\n",
+    "The sklearn digits dataset uses 8x8 images with pixel values 0–16.\n",
+    "\n",
+    "Draw a digit below using binary (0/1) values — we will scale to 0–16 for prediction."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "mnist_pad = DrawingPad(pix_zoom=48, data=np.zeros((8, 8), dtype=np.float32))\n",
+    "mnist_pad"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 5c. Predict the drawn digit\n",
+    "\n",
+    "Run this cell after drawing."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "drawn = mnist_pad.get_data()\n",
+    "\n",
+    "# Scale binary (0/1) to sklearn digits range (0-16)\n",
+    "drawn_scaled = (drawn * 16.0).astype(np.float64)\n",
+    "\n",
+    "# Visualize what we're feeding to the classifier\n",
+    "fig, axes = plt.subplots(1, 2, figsize=(6, 3))\n",
+    "axes[0].imshow(drawn, cmap=\"gray_r\", interpolation=\"nearest\")\n",
+    "axes[0].set_title(\"Raw drawing (0/1)\")\n",
+    "axes[0].axis(\"off\")\n",
+    "axes[1].imshow(drawn_scaled.reshape(8, 8), cmap=\"gray_r\", interpolation=\"nearest\")\n",
+    "axes[1].set_title(\"Scaled (0-16)\")\n",
+    "axes[1].axis(\"off\")\n",
+    "plt.tight_layout()\n",
+    "plt.show()\n",
+    "\n",
+    "# Predict\n",
+    "prediction = clf.predict(drawn_scaled.reshape(1, -1))[0]\n",
+    "probas = clf.predict_proba(drawn_scaled.reshape(1, -1))[0]\n",
+    "\n",
+    "print(f\"\\nPredicted digit: {prediction}\")\n",
+    "print(f\"Confidence:      {probas[prediction]:.1%}\")\n",
+    "print(f\"\\nAll probabilities:\")\n",
+    "for digit, prob in enumerate(probas):\n",
+    "    bar = '█' * int(prob * 30)\n",
+    "    print(f\"  {digit}: {prob:5.1%} {bar}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 5d. Load a real MNIST digit into the pad\n",
+    "\n",
+    "Pick a digit from the dataset and load it into the drawing pad for inspection or editing."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Pick digit index (0-1796)\n",
+    "digit_index = 42\n",
+    "\n",
+    "sample = digits.images[digit_index].astype(np.float32)\n",
+    "label = digits.target[digit_index]\n",
+    "print(f\"Loading digit at index {digit_index} (label: {label})\")\n",
+    "\n",
+    "# Normalize to 0-1 range for the pad\n",
+    "sample_normalized = sample / 16.0\n",
+    "\n",
+    "inspect_pad = DrawingPad(pix_zoom=48, data=sample_normalized)\n",
+    "inspect_pad"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Predict the (possibly edited) digit\n",
+    "edited = inspect_pad.get_data()\n",
+    "edited_scaled = (edited * 16.0).astype(np.float64)\n",
+    "\n",
+    "prediction = clf.predict(edited_scaled.reshape(1, -1))[0]\n",
+    "print(f\"Original label: {label}\")\n",
+    "print(f\"Predicted:      {prediction}\")"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.13.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}