signspell 1.0.0__tar.gz

signspell-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Sundar
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

signspell-1.0.0/MANIFEST.in

@@ -0,0 +1,3 @@
+include README.md
+include LICENSE
+recursive-include src/asl_alphabet/models *.h5

signspell-1.0.0/PKG-INFO

@@ -0,0 +1,116 @@
+Metadata-Version: 2.4
+Name: signspell
+Version: 1.0.0
+Summary: Live ASL fingerspelling alphabet recognition with a polished webcam UI.
+Author-email: Sundar <you@example.com>
+License: MIT
+Project-URL: Homepage, https://github.com/TheMadrasTechie/signspell
+Project-URL: Repository, https://github.com/TheMadrasTechie/signspell
+Project-URL: Issues, https://github.com/TheMadrasTechie/signspell/issues
+Keywords: asl,sign-language,computer-vision,mediapipe,fingerspelling,accessibility
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Education
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Topic :: Scientific/Engineering :: Image Recognition
+Classifier: Topic :: Multimedia :: Video :: Capture
+Requires-Python: <3.12,>=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy<2
+Requires-Dist: opencv-python<4.10
+Requires-Dist: mediapipe<0.11,>=0.10
+Requires-Dist: tensorflow<2.16,>=2.15
+Provides-Extra: dev
+Requires-Dist: build; extra == "dev"
+Requires-Dist: twine; extra == "dev"
+Requires-Dist: pytest; extra == "dev"
+Dynamic: license-file
+
+# signspell
+
+**Live ASL fingerspelling alphabet recognition — straight from your webcam.**
+
+`signspell` recognises the American Sign Language manual alphabet (A–Z) in real
+time using MediaPipe hand tracking and an LSTM model trained on 30-frame
+keypoint sequences. It ships with a pretrained model and a polished webcam UI,
+and it works both as a command-line tool and an importable library.
+
+---
+
+## Install
+
+```bash
+pip install signspell
+```
+
+> Requires Python 3.9–3.11. A webcam is required for live recognition.
+
+## Run it (CLI)
+
+```bash
+signspell                  # default webcam, bundled model, pro UI
+signspell --camera 1       # pick a different camera
+signspell --threshold 0.6  # require higher confidence
+signspell --no-mirror      # disable mirrored view
+```
+
+**In-window keys:** `q` quit · `c` clear sentence · `SPACE` add a space.
+
+## Use it (library)
+
+Run the full UI from code:
+
+```python
+import signspell
+signspell.run()
+```
+
+Or drive recognition yourself, frame by frame:
+
+```python
+import cv2
+import signspell
+
+rec = signspell.Recognizer()
+cap = cv2.VideoCapture(0)
+
+while True:
+    ok, frame = cap.read()
+    if not ok:
+        break
+    letter, confidence, probs = rec.predict(frame)
+    if letter:
+        print(letter, f"{confidence:.2f}")
+```
+
+The `Recognizer` keeps a rolling 30-frame buffer internally, so you just feed
+frames and read predictions. `letter` is `None` until the buffer fills or when
+confidence is below the threshold.
+
+## How it works
+
+1. **MediaPipe Holistic** extracts 21 right-hand landmarks per frame.
+2. The last **30 frames** of `(x, y, z)` keypoints form a sequence.
+3. An **LSTM** classifies the sequence into one of 26 letters.
+4. A short stability window prevents flicker before a letter is committed.
+
+## Bring your own model
+
+```bash
+signspell --model path/to/your_model.h5
+```
+
+```python
+signspell.Recognizer(model_path="path/to/your_model.h5")
+```
+
+Your model must accept input shape `(1, 30, 63)` and output 26 class scores.
+
+## License
+
+MIT © Sundar

signspell-1.0.0/README.md

@@ -0,0 +1,83 @@
+# signspell
+
+**Live ASL fingerspelling alphabet recognition — straight from your webcam.**
+
+`signspell` recognises the American Sign Language manual alphabet (A–Z) in real
+time using MediaPipe hand tracking and an LSTM model trained on 30-frame
+keypoint sequences. It ships with a pretrained model and a polished webcam UI,
+and it works both as a command-line tool and an importable library.
+
+---
+
+## Install
+
+```bash
+pip install signspell
+```
+
+> Requires Python 3.9–3.11. A webcam is required for live recognition.
+
+## Run it (CLI)
+
+```bash
+signspell                  # default webcam, bundled model, pro UI
+signspell --camera 1       # pick a different camera
+signspell --threshold 0.6  # require higher confidence
+signspell --no-mirror      # disable mirrored view
+```
+
+**In-window keys:** `q` quit · `c` clear sentence · `SPACE` add a space.
+
+## Use it (library)
+
+Run the full UI from code:
+
+```python
+import signspell
+signspell.run()
+```
+
+Or drive recognition yourself, frame by frame:
+
+```python
+import cv2
+import signspell
+
+rec = signspell.Recognizer()
+cap = cv2.VideoCapture(0)
+
+while True:
+    ok, frame = cap.read()
+    if not ok:
+        break
+    letter, confidence, probs = rec.predict(frame)
+    if letter:
+        print(letter, f"{confidence:.2f}")
+```
+
+The `Recognizer` keeps a rolling 30-frame buffer internally, so you just feed
+frames and read predictions. `letter` is `None` until the buffer fills or when
+confidence is below the threshold.
+
+## How it works
+
+1. **MediaPipe Holistic** extracts 21 right-hand landmarks per frame.
+2. The last **30 frames** of `(x, y, z)` keypoints form a sequence.
+3. An **LSTM** classifies the sequence into one of 26 letters.
+4. A short stability window prevents flicker before a letter is committed.
+
+## Bring your own model
+
+```bash
+signspell --model path/to/your_model.h5
+```
+
+```python
+signspell.Recognizer(model_path="path/to/your_model.h5")
+```
+
+Your model must accept input shape `(1, 30, 63)` and output 26 class scores.
+
+## License
+
+MIT © Sundar

signspell-1.0.0/pyproject.toml

@@ -0,0 +1,48 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "signspell"
+version = "1.0.0"
+description = "Live ASL fingerspelling alphabet recognition with a polished webcam UI."
+readme = "README.md"
+requires-python = ">=3.9,<3.12"
+license = { text = "MIT" }
+authors = [{ name = "Sundar", email = "you@example.com" }]
+keywords = ["asl", "sign-language", "computer-vision", "mediapipe", "fingerspelling", "accessibility"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Intended Audience :: Education",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Topic :: Scientific/Engineering :: Image Recognition",
+    "Topic :: Multimedia :: Video :: Capture",
+]
+dependencies = [
+    "numpy<2",
+    "opencv-python<4.10",
+    "mediapipe>=0.10,<0.11",
+    "tensorflow>=2.15,<2.16",
+]
+
+[project.urls]
+Homepage = "https://github.com/TheMadrasTechie/signspell"
+Repository = "https://github.com/TheMadrasTechie/signspell"
+Issues = "https://github.com/TheMadrasTechie/signspell/issues"
+
+[project.scripts]
+signspell = "asl_alphabet.cli:main"
+
+[project.optional-dependencies]
+dev = ["build", "twine", "pytest"]
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+asl_alphabet = ["models/*.h5"]

signspell-1.0.0/setup.cfg

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

signspell-1.0.0/src/asl_alphabet/__init__.py

@@ -0,0 +1,21 @@
+"""
+signspell — live ASL fingerspelling alphabet recognition.
+
+Quick start
+-----------
+    import signspell
+
+    # Run the live recognizer with the bundled model and pro UI:
+    signspell.run()
+
+    # Or drive it yourself, frame by frame:
+    rec = signspell.Recognizer()
+    letter, confidence, probabilities = rec.predict(frame_bgr)
+"""
+
+from .recognizer import Recognizer
+from .app import run
+from .config import ACTIONS, SEQUENCE_LENGTH
+
+__version__ = "0.1.0"
+__all__ = ["Recognizer", "run", "ACTIONS", "SEQUENCE_LENGTH", "__version__"]

signspell-1.0.0/src/asl_alphabet/app.py

@@ -0,0 +1,188 @@
+"""
+Live application: pro UI built on top of the headless Recognizer.
+
+Public entry point: signspell.run(...) — also wired to the `signspell` CLI.
+"""
+
+import time
+from typing import Optional
+
+import numpy as np
+
+from .config import ACTIONS, SEQUENCE_LENGTH, DEFAULT_THRESHOLD, STABILITY_WINDOW
+from .recognizer import Recognizer
+
+# Colour palette (BGR)
+C_BG_PANEL = (28, 28, 32)
+C_ACCENT = (245, 166, 35)
+C_ACCENT_2 = (88, 214, 141)
+C_TEXT = (240, 240, 240)
+C_TEXT_DIM = (150, 150, 155)
+
+
+def _rounded_panel(img, x1, y1, x2, y2, color, alpha=0.78):
+    import cv2
+    overlay = img.copy()
+    cv2.rectangle(overlay, (x1, y1), (x2, y2), color, -1)
+    cv2.addWeighted(overlay, alpha, img, 1 - alpha, 0, img)
+
+
+def _draw_hand(image, results):
+    import cv2
+    from mediapipe.python.solutions import holistic as mp_holistic
+
+    lm = results.right_hand_landmarks
+    if not lm:
+        return
+    h, w = image.shape[:2]
+    pts = [(int(p.x * w), int(p.y * h), p.z) for p in lm.landmark]
+
+    for a, b in mp_holistic.HAND_CONNECTIONS:
+        pa, pb = pts[a][:2], pts[b][:2]
+        cv2.line(image, pa, pb, (0, 0, 0), 5, cv2.LINE_AA)
+        cv2.line(image, pa, pb, C_ACCENT, 2, cv2.LINE_AA)
+
+    zs = [p[2] for p in pts]
+    zmin, zmax = min(zs), max(zs)
+    span = (zmax - zmin) or 1e-6
+    for (x, y, z) in pts:
+        t = 1.0 - (z - zmin) / span
+        r = int(3 + 5 * t)
+        col = (int(66 + 150 * t), int(180 + 60 * t), 230)
+        cv2.circle(image, (x, y), r + 2, (0, 0, 0), -1, cv2.LINE_AA)
+        cv2.circle(image, (x, y), r, col, -1, cv2.LINE_AA)
+
+
+def _draw_prob_panel(image, probs):
+    import cv2
+    h, w = image.shape[:2]
+    pw = 230
+    x0 = w - pw
+    _rounded_panel(image, x0, 0, w, h, C_BG_PANEL, 0.72)
+    cv2.putText(image, "CONFIDENCE", (x0 + 16, 32),
+                cv2.FONT_HERSHEY_SIMPLEX, 0.6, C_TEXT_DIM, 1, cv2.LINE_AA)
+    order = np.argsort(probs)[::-1][:8]
+    y = 58
+    for rank, idx in enumerate(order):
+        prob = float(probs[idx])
+        bar_w = int(prob * (pw - 80))
+        col = C_ACCENT_2 if rank == 0 else C_ACCENT
+        cv2.putText(image, ACTIONS[idx], (x0 + 16, y + 20),
+                    cv2.FONT_HERSHEY_SIMPLEX, 0.7,
+                    C_TEXT if rank == 0 else C_TEXT_DIM, 2, cv2.LINE_AA)
+        cv2.rectangle(image, (x0 + 46, y + 5), (x0 + 46 + (pw - 80), y + 22),
+                      (50, 50, 55), -1)
+        cv2.rectangle(image, (x0 + 46, y + 5), (x0 + 46 + bar_w, y + 22), col, -1)
+        cv2.putText(image, f"{prob*100:4.0f}%", (x0 + pw - 28, y + 20),
+                    cv2.FONT_HERSHEY_SIMPLEX, 0.4, C_TEXT_DIM, 1, cv2.LINE_AA)
+        y += 34
+
+
+def _draw_sentence_bar(image, sentence, top_conf, threshold):
+    import cv2
+    h, w = image.shape[:2]
+    _rounded_panel(image, 0, 0, w - 230, 56, C_BG_PANEL, 0.78)
+    text = ''.join(sentence) if sentence else "..."
+    cv2.putText(image, text, (16, 40),
+                cv2.FONT_HERSHEY_SIMPLEX, 1.1, C_TEXT, 2, cv2.LINE_AA)
+    meter_w = int((w - 230) * top_conf)
+    cv2.rectangle(image, (0, 56), (w - 230, 60), (50, 50, 55), -1)
+    col = C_ACCENT_2 if top_conf > threshold else C_ACCENT
+    cv2.rectangle(image, (0, 56), (meter_w, 60), col, -1)
+
+
+def _draw_status(image, fps, hand_present):
+    import cv2
+    h, w = image.shape[:2]
+    _rounded_panel(image, 0, h - 34, 200, h, C_BG_PANEL, 0.7)
+    cv2.putText(image, f"FPS {fps:4.1f}", (12, h - 12),
+                cv2.FONT_HERSHEY_SIMPLEX, 0.55, C_TEXT, 1, cv2.LINE_AA)
+    dot = C_ACCENT_2 if hand_present else (80, 80, 90)
+    cv2.circle(image, (130, h - 17), 7, dot, -1, cv2.LINE_AA)
+    cv2.putText(image, "HAND", (145, h - 12),
+                cv2.FONT_HERSHEY_SIMPLEX, 0.45,
+                C_TEXT if hand_present else C_TEXT_DIM, 1, cv2.LINE_AA)
+
+
+def run(
+    model_path: Optional[str] = None,
+    camera: int = 0,
+    threshold: float = DEFAULT_THRESHOLD,
+    mirror: bool = True,
+    window_name: str = "signspell — ASL Alphabet",
+):
+    """Launch the live recognizer with the pro UI.
+
+    Keys:  q = quit | c = clear sentence | SPACE = add a space
+    """
+    import cv2
+
+    rec = Recognizer(model_path=model_path, threshold=threshold)
+
+    sentence, predictions = [], []
+    probs = np.zeros(len(ACTIONS))
+    prev_t = time.time()
+    fps = 0.0
+
+    cap = cv2.VideoCapture(camera)
+    if not cap.isOpened():
+        rec.close()
+        raise RuntimeError(
+            f"Could not open camera index {camera}. Try 0, 1, or 2."
+        )
+
+    try:
+        while cap.isOpened():
+            ret, frame = cap.read()
+            if not ret:
+                break
+            if mirror:
+                frame = cv2.flip(frame, 1)
+
+            letter, conf, p = rec.predict(frame)
+            results = rec.last_results
+            hand_present = results.right_hand_landmarks is not None
+            if p is not None:
+                probs = p
+
+            # Draw on a BGR copy
+            image = cv2.cvtColor(
+                cv2.cvtColor(frame, cv2.COLOR_BGR2RGB), cv2.COLOR_RGB2BGR
+            )
+            _draw_hand(image, results)
+
+            # Stabilise before committing a letter to the sentence
+            if p is not None:
+                predictions.append(int(np.argmax(probs)))
+                if (
+                    len(predictions) >= STABILITY_WINDOW
+                    and len(np.unique(predictions[-STABILITY_WINDOW:])) == 1
+                    and letter is not None
+                ):
+                    if not sentence or letter != sentence[-1]:
+                        sentence.append(letter)
+                if len(sentence) > 12:
+                    sentence = sentence[-12:]
+
+            now = time.time()
+            inst = 1.0 / max(now - prev_t, 1e-6)
+            fps = 0.9 * fps + 0.1 * inst if fps else inst
+            prev_t = now
+
+            top_conf = float(probs[np.argmax(probs)]) if probs.any() else 0.0
+            _draw_prob_panel(image, probs)
+            _draw_sentence_bar(image, sentence, top_conf, threshold)
+            _draw_status(image, fps, hand_present)
+
+            cv2.imshow(window_name, image)
+            key = cv2.waitKey(10) & 0xFF
+            if key == ord('q'):
+                break
+            elif key == ord('c'):
+                sentence = []
+            elif key == ord(' '):
+                sentence.append(' ')
+    finally:
+        cap.release()
+        cv2.destroyAllWindows()
+        rec.close()

signspell-1.0.0/src/asl_alphabet/cli.py

@@ -0,0 +1,46 @@
+"""Command-line interface for signspell."""
+
+import argparse
+
+from . import __version__
+from .app import run
+from .config import DEFAULT_THRESHOLD
+
+
+def main(argv=None):
+    parser = argparse.ArgumentParser(
+        prog="signspell",
+        description="Live ASL fingerspelling alphabet recognition.",
+    )
+    parser.add_argument(
+        "-c", "--camera", type=int, default=0,
+        help="Camera index (default: 0).",
+    )
+    parser.add_argument(
+        "-m", "--model", default=None,
+        help="Path to a custom .h5 model (default: bundled model).",
+    )
+    parser.add_argument(
+        "-t", "--threshold", type=float, default=DEFAULT_THRESHOLD,
+        help=f"Confidence threshold (default: {DEFAULT_THRESHOLD}).",
+    )
+    parser.add_argument(
+        "--no-mirror", action="store_true",
+        help="Disable the mirrored webcam view.",
+    )
+    parser.add_argument(
+        "-V", "--version", action="version",
+        version=f"signspell {__version__}",
+    )
+    args = parser.parse_args(argv)
+
+    run(
+        model_path=args.model,
+        camera=args.camera,
+        threshold=args.threshold,
+        mirror=not args.no_mirror,
+    )
+
+
+if __name__ == "__main__":
+    main()

signspell-1.0.0/src/asl_alphabet/config.py

@@ -0,0 +1,26 @@
+"""Shared configuration and constants."""
+
+from importlib import resources
+import numpy as np
+
+# Model input contract — must match how the model was trained.
+ACTIONS = np.array(
+    ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
+     'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z']
+)
+SEQUENCE_LENGTH = 30          # frames per prediction window
+NUM_KEYPOINTS = 21 * 3        # right hand: 21 landmarks x (x, y, z)
+
+DEFAULT_THRESHOLD = 0.5
+STABILITY_WINDOW = 10         # consecutive agreeing frames before a letter sticks
+
+# Bundled model filename (lives in asl_alphabet/models/)
+MODEL_FILENAME = "alphabet_30_30_all_4.h5"
+
+
+def default_model_path() -> str:
+    """Return the filesystem path to the model bundled inside the package."""
+    with resources.as_file(
+        resources.files("asl_alphabet.models") / MODEL_FILENAME
+    ) as p:
+        return str(p)

signspell-1.0.0/src/asl_alphabet/recognizer.py

@@ -0,0 +1,114 @@
+"""
+Headless recognition engine.
+
+The Recognizer wraps MediaPipe Holistic + the trained LSTM and exposes a
+simple frame-in / prediction-out API. It holds the rolling 30-frame buffer
+internally so callers just feed frames.
+"""
+
+from collections import deque
+from typing import Optional, Tuple
+
+import numpy as np
+
+from .config import (
+    ACTIONS,
+    SEQUENCE_LENGTH,
+    NUM_KEYPOINTS,
+    DEFAULT_THRESHOLD,
+    default_model_path,
+)
+
+
+class Recognizer:
+    """Live ASL alphabet recognizer.
+
+    Parameters
+    ----------
+    model_path : str, optional
+        Path to a Keras .h5 model. Defaults to the bundled model.
+    threshold : float
+        Minimum softmax confidence for a prediction to count as a letter.
+    min_detection_confidence, min_tracking_confidence : float
+        Passed straight to MediaPipe Holistic.
+    """
+
+    def __init__(
+        self,
+        model_path: Optional[str] = None,
+        threshold: float = DEFAULT_THRESHOLD,
+        min_detection_confidence: float = 0.5,
+        min_tracking_confidence: float = 0.5,
+    ):
+        # Imported lazily so `import signspell` is cheap and so that a missing
+        # heavy dep surfaces a clear message only when you actually run.
+        import mediapipe as mp
+        from tensorflow.keras.models import load_model
+
+        self.threshold = threshold
+        self._model = load_model(model_path or default_model_path())
+
+        self._mp_holistic = mp.solutions.holistic
+        self._holistic = self._mp_holistic.Holistic(
+            min_detection_confidence=min_detection_confidence,
+            min_tracking_confidence=min_tracking_confidence,
+        )
+        self._sequence = deque(maxlen=SEQUENCE_LENGTH)
+        self._last_results = None
+
+    # -- public API --------------------------------------------------------
+    def process(self, frame_bgr):
+        """Run MediaPipe on a BGR frame; returns the raw results object."""
+        import cv2
+
+        image_rgb = cv2.cvtColor(frame_bgr, cv2.COLOR_BGR2RGB)
+        image_rgb.flags.writeable = False
+        results = self._holistic.process(image_rgb)
+        self._last_results = results
+        return results
+
+    def predict(
+        self, frame_bgr
+    ) -> Tuple[Optional[str], float, Optional[np.ndarray]]:
+        """Feed one frame, return (letter, confidence, full_prob_vector).
+
+        `letter` is None until the 30-frame buffer fills or when confidence
+        is below threshold. `probabilities` is the length-26 softmax vector
+        (or None before the buffer is full).
+        """
+        results = self.process(frame_bgr)
+        self._sequence.append(self._extract_keypoints(results))
+
+        if len(self._sequence) < SEQUENCE_LENGTH:
+            return None, 0.0, None
+
+        probs = self._model.predict(
+            np.expand_dims(np.array(self._sequence), axis=0), verbose=0
+        )[0]
+        idx = int(np.argmax(probs))
+        conf = float(probs[idx])
+        letter = ACTIONS[idx] if conf >= self.threshold else None
+        return letter, conf, probs
+
+    @property
+    def last_results(self):
+        """MediaPipe results from the most recent process()/predict() call."""
+        return self._last_results
+
+    def close(self):
+        self._holistic.close()
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *exc):
+        self.close()
+
+    # -- internals ---------------------------------------------------------
+    @staticmethod
+    def _extract_keypoints(results) -> np.ndarray:
+        if results.right_hand_landmarks:
+            return np.array(
+                [[r.x, r.y, r.z] for r in results.right_hand_landmarks.landmark]
+            ).flatten()
+        return np.zeros(NUM_KEYPOINTS)

signspell-1.0.0/src/signspell.egg-info/PKG-INFO

@@ -0,0 +1,116 @@
+Metadata-Version: 2.4
+Name: signspell
+Version: 1.0.0
+Summary: Live ASL fingerspelling alphabet recognition with a polished webcam UI.
+Author-email: Sundar <you@example.com>
+License: MIT
+Project-URL: Homepage, https://github.com/TheMadrasTechie/signspell
+Project-URL: Repository, https://github.com/TheMadrasTechie/signspell
+Project-URL: Issues, https://github.com/TheMadrasTechie/signspell/issues
+Keywords: asl,sign-language,computer-vision,mediapipe,fingerspelling,accessibility
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Education
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Topic :: Scientific/Engineering :: Image Recognition
+Classifier: Topic :: Multimedia :: Video :: Capture
+Requires-Python: <3.12,>=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy<2
+Requires-Dist: opencv-python<4.10
+Requires-Dist: mediapipe<0.11,>=0.10
+Requires-Dist: tensorflow<2.16,>=2.15
+Provides-Extra: dev
+Requires-Dist: build; extra == "dev"
+Requires-Dist: twine; extra == "dev"
+Requires-Dist: pytest; extra == "dev"
+Dynamic: license-file
+
+# signspell
+
+**Live ASL fingerspelling alphabet recognition — straight from your webcam.**
+
+`signspell` recognises the American Sign Language manual alphabet (A–Z) in real
+time using MediaPipe hand tracking and an LSTM model trained on 30-frame
+keypoint sequences. It ships with a pretrained model and a polished webcam UI,
+and it works both as a command-line tool and an importable library.
+
+---
+
+## Install
+
+```bash
+pip install signspell
+```
+
+> Requires Python 3.9–3.11. A webcam is required for live recognition.
+
+## Run it (CLI)
+
+```bash
+signspell                  # default webcam, bundled model, pro UI
+signspell --camera 1       # pick a different camera
+signspell --threshold 0.6  # require higher confidence
+signspell --no-mirror      # disable mirrored view
+```
+
+**In-window keys:** `q` quit · `c` clear sentence · `SPACE` add a space.
+
+## Use it (library)
+
+Run the full UI from code:
+
+```python
+import signspell
+signspell.run()
+```
+
+Or drive recognition yourself, frame by frame:
+
+```python
+import cv2
+import signspell
+
+rec = signspell.Recognizer()
+cap = cv2.VideoCapture(0)
+
+while True:
+    ok, frame = cap.read()
+    if not ok:
+        break
+    letter, confidence, probs = rec.predict(frame)
+    if letter:
+        print(letter, f"{confidence:.2f}")
+```
+
+The `Recognizer` keeps a rolling 30-frame buffer internally, so you just feed
+frames and read predictions. `letter` is `None` until the buffer fills or when
+confidence is below the threshold.
+
+## How it works
+
+1. **MediaPipe Holistic** extracts 21 right-hand landmarks per frame.
+2. The last **30 frames** of `(x, y, z)` keypoints form a sequence.
+3. An **LSTM** classifies the sequence into one of 26 letters.
+4. A short stability window prevents flicker before a letter is committed.
+
+## Bring your own model
+
+```bash
+signspell --model path/to/your_model.h5
+```
+
+```python
+signspell.Recognizer(model_path="path/to/your_model.h5")
+```
+
+Your model must accept input shape `(1, 30, 63)` and output 26 class scores.
+
+## License
+
+MIT © Sundar

signspell-1.0.0/src/signspell.egg-info/SOURCES.txt

@@ -0,0 +1,16 @@
+LICENSE
+MANIFEST.in
+README.md
+pyproject.toml
+src/asl_alphabet/__init__.py
+src/asl_alphabet/app.py
+src/asl_alphabet/cli.py
+src/asl_alphabet/config.py
+src/asl_alphabet/recognizer.py
+src/asl_alphabet/models/alphabet_30_30_all_4.h5
+src/signspell.egg-info/PKG-INFO
+src/signspell.egg-info/SOURCES.txt
+src/signspell.egg-info/dependency_links.txt
+src/signspell.egg-info/entry_points.txt
+src/signspell.egg-info/requires.txt
+src/signspell.egg-info/top_level.txt

signspell-1.0.0/src/signspell.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

signspell-1.0.0/src/signspell.egg-info/entry_points.txt

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

signspell-1.0.0/src/signspell.egg-info/requires.txt

@@ -0,0 +1,9 @@
+numpy<2
+opencv-python<4.10
+mediapipe<0.11,>=0.10
+tensorflow<2.16,>=2.15
+
+[dev]
+build
+twine
+pytest

signspell-1.0.0/src/signspell.egg-info/top_level.txt

@@ -0,0 +1 @@
+asl_alphabet