numclassify 0.3.2.1__tar.gz → 0.4.0__tar.gz

{numclassify-0.3.2.1 → numclassify-0.4.0}/.gitignore

@@ -10,3 +10,4 @@ dist/
 .env
 .venv 
 site/
+.offline-markdown-preview/

{numclassify-0.3.2.1 → numclassify-0.4.0}/CHANGELOG.md

@@ -6,11 +6,53 @@ This project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.htm
 
 ---
 
+## [0.4.0] - 2026-06-13
+
+### Fixed
+- `classify()` now returns `notable_score` field — score excluding figurate/centered-figurate
+  hits. Prevents misleading score inflation for n=1 (which is the first member of every
+  polygonal sequence).
+- `is_unique(n)` now returns `False` for negative `n`. Previously returned `True` due to
+  `abs()` stripping the sign.
+- `is_practical(0)` now returns `False`. Previously returned `True` because
+  `_factorization(0)` returns `[]` and the loop never ran.
+- Removed leaked internal names (`Optional`, `_version`, `_PackageNotFoundError`) from
+  `dir(numclassify)`.
+
+### Changed
+- Development status updated to `5 - Production/Stable` in package classifiers.
+
+### Added
+- `SECURITY.md` with vulnerability reporting instructions.
+
+## [0.3.3] - 2026-06-13
+
+### Added
+- 8 new exam number types in `numclassify/_core/exam_types.py`:
+  Strong, Sunny, Buzz, Magic, Fascinating, Trimorphic, Twisted Prime, Unique
+- `classify()` now returns a `"categories"` dict grouping true properties by category
+- `classify()` true_properties list is now sorted by category then name
+- `stream()` now accepts `min_score` and `has_property` filter parameters
+- `most_special_in_range()` now accepts `verbose=True` for progress output
+- `find_any_in_range()` exported in public API (was implemented but not accessible)
+- Auto-generated crash tests: every registered type tested on inputs 0, 1, 2, -1
+
+### Fixed
+- Removed dead `else` branch in `classify()` (unreachable code)
+- Removed `del annotations` no-op in `__init__.py`
+- Fixed wrong docstring example in `is_leyland_prime` (593 is True, not False)
+- Removed dead `pass` block in `is_centered_k_gonal` in `figurate.py`
+- Documented `is_sociable` cycle detection cap (chains > 6 not detected)
+
 ## [0.3.2.1] - 2026-06-12
 
 ### Fixed
+- Batch classify input rejected commas/spaces — changed `type="number"` to `type="text"` with `inputmode="numeric"`
 - Search autocomplete dropdown not appearing — added fallback fetch of property names if initial Pyodide load fails, plus visible "Loading..." state in dropdown
 
+### Changed
+- MkDocs site theme changed from indigo to saffron (#FF9933) via custom CSS
+
 ## [0.3.2] - 2026-06-12
 
 ### Added

{numclassify-0.3.2.1 → numclassify-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: numclassify
-Version: 0.3.2.1
+Version: 0.4.0
 Summary: The most comprehensive Python library for number classification - 3000+ number types
 Project-URL: Homepage, https://github.com/aratrikghosh2011-tech/numclassify
 Project-URL: Repository, https://github.com/aratrikghosh2011-tech/numclassify
@@ -10,7 +10,7 @@ Author-email: Aratrik Ghosh <aratrikghosh2011@gmail.com>
 License: MIT
 License-File: LICENSE
 Keywords: armstrong,classification,figurate,mathematics,number-theory,prime
-Classifier: Development Status :: 4 - Beta
+Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Education
 Classifier: Intended Audience :: Science/Research
 Classifier: License :: OSI Approved :: MIT License

numclassify-0.4.0/SECURITY.md

@@ -0,0 +1,24 @@
+# Security Policy
+
+## Supported Versions
+
+Only the latest release on PyPI is supported.
+
+| Version | Supported |
+|---------|-----------|
+| 0.4.x   | ✅        |
+| < 0.4   | ❌        |
+
+## Reporting a Vulnerability
+
+To report a security vulnerability, email **aratrikghosh2011@gmail.com** with
+the subject line `[numclassify] Security Report`.
+
+Please include:
+- A description of the vulnerability
+- Steps to reproduce
+- Potential impact
+
+You can expect an acknowledgment within 48 hours. Since `numclassify` is a
+pure computation library with no network access, no file system writes, and no
+external dependencies, the attack surface is minimal.

{numclassify-0.3.2.1 → numclassify-0.4.0}/docs/playground.html

@@ -45,7 +45,7 @@
       <div class="card">
         <div class="card-title">Classify a Number</div>
         <div class="input-row">
-          <input type="number" id="input-classify" placeholder="Enter any integer... (or 6, 28, 496 for batch)" min="-999999" max="999999" />
+          <input type="text" id="input-classify" inputmode="numeric" pattern="-?[0-9\s,]*" placeholder="Enter any integer... (or 6, 28, 496 for batch)" />
           <button class="btn" id="btn-classify" onclick="doClassify()">Classify</button>
           <button class="btn btn-ghost" onclick="doRandom()">Random</button>
         </div>

{numclassify-0.3.2.1 → numclassify-0.4.0}/numclassify/__init__.py

@@ -26,7 +26,6 @@ Public API
 """
 
 from __future__ import annotations
-del annotations
 
 from importlib.metadata import version as _version, PackageNotFoundError as _PackageNotFoundError
 try:
@@ -44,6 +43,7 @@ from numclassify._core import sequences as _sequences     # noqa: F401
 from numclassify._core import powers as _powers        # noqa: F401
 from numclassify._core import number_theory as _number_theory # noqa: F401
 from numclassify._core import combinatorial as _combinatorial # noqa: F401
+from numclassify._core import exam_types as _exam_types      # noqa: F401
 
 # --- Re-export key functions at top level ---
 from numclassify._core.primes import is_prime         # noqa: F401
@@ -56,6 +56,7 @@ from numclassify._registry import (                   # noqa: F401
     print_properties,
     find_in_range,
     find_all_in_range,
+    find_any_in_range,
     count_properties,
     most_special_in_range,
 )
@@ -86,20 +87,39 @@ def classify(n: int) -> dict:
     -------
     {
         "number": n,
-        "true_properties": [list of property names that are True],
-        "score": int,   # count of True properties
+        "true_properties": [list of property names that are True, sorted by category],
+        "score": int,
+        "categories": {category_name: [list of property names]},
     }
     """
-    raw = get_true_properties(n)
-    if isinstance(raw, dict):
-        true_props = [k for k, v in raw.items() if v]
-    else:
-        true_props = list(raw)
+    from numclassify._registry import REGISTRY, _normalize
+
+    all_props = get_all_properties(n)
+    true_props_with_cat = []
+    for name, val in all_props.items():
+        if val:
+            key = _normalize(name)
+            cat = REGISTRY[key].category if key in REGISTRY else "other"
+            true_props_with_cat.append((name, cat))
+
+    # Sort by category then name
+    true_props_with_cat.sort(key=lambda x: (x[1], x[0]))
+    true_props = [name for name, _ in true_props_with_cat]
+
+    # Build categories dict
+    categories: dict = {}
+    for name, cat in true_props_with_cat:
+        categories.setdefault(cat, []).append(name)
 
     return {
         "number": n,
         "true_properties": true_props,
         "score": len(true_props),
+        "notable_score": sum(
+            len(v) for k, v in categories.items()
+            if k not in ("figurate", "figurate_centered")
+        ),
+        "categories": categories,
     }
 
 
@@ -150,10 +170,48 @@ def find_by_property(start: int = 1, end: int = 1000,
     return results
 
 
-def stream(start: int, end: int):
-    """Generator. Yields classify(n) for each n in [start, end]. Memory-safe for large ranges."""
+from typing import Optional
+
+def stream(start: int, end: int, min_score: int = 0, has_property: Optional[str] = None):
+    """Generator. Yields classify(n) for each n in [start, end]. Memory-safe.
+
+    Parameters
+    ----------
+    start, end : int
+        Inclusive range.
+    min_score : int, optional
+        Only yield results with score >= min_score. Default 0 (yield all).
+    has_property : str, optional
+        Only yield results where this property is True.
+        Accepts any registered property name (case-insensitive, spaces or underscores).
+
+    Example
+    -------
+    # Only numbers with more than 20 true properties
+    for result in nc.stream(1, 10000, min_score=20):
+        print(result)
+
+    # Only fibonacci numbers in a range
+    for result in nc.stream(1, 1000, has_property='fibonacci'):
+        print(result['number'])
+    """
+    from numclassify._registry import REGISTRY, _normalize, get_all_properties as _gap
+
+    prop_key = _normalize(has_property) if has_property else None
+
     for n in range(start, end + 1):
-        yield classify(n)
+        result = classify(n)
+        if result["score"] < min_score:
+            continue
+        if prop_key is not None:
+            props = _gap(n)
+            # find by normalized key
+            matched = any(
+                _normalize(k) == prop_key for k, v in props.items() if v
+            )
+            if not matched:
+                continue
+        yield result
 
 
 # ---------------------------------------------------------------------------
@@ -162,6 +220,7 @@ def stream(start: int, end: int):
 
 __all__ = [
     "__version__",
+    "register",
     "is_prime",
     "is_armstrong",
     "is_perfect",
@@ -170,6 +229,7 @@ __all__ = [
     "print_properties",
     "find_in_range",
     "find_all_in_range",
+    "find_any_in_range",
     "count_properties",
     "most_special_in_range",
     "classify",
@@ -182,4 +242,5 @@ __all__ = [
 # Clean up internal names that leak into dir(nc)
 del (_primes, _figurate, _digital, _recreational,
      _divisors, _sequences, _powers, _number_theory,
-     _combinatorial, _core, _registry)
+     _combinatorial, _exam_types, _core, _registry,
+     Optional, _version, _PackageNotFoundError)

{numclassify-0.3.2.1 → numclassify-0.4.0}/numclassify/_core/divisors.py

@@ -273,7 +273,7 @@ def is_amicable(n: int) -> bool:
 
 
 @register(name="Sociable", category="divisors", oeis="A003416",
-          description="Part of an aliquot cycle of length > 2 (checked up to length 6).")
+          description="Part of an aliquot cycle of length 3–6 (longer chains not detected).")
 def is_sociable(n: int) -> bool:
     """Return True if n is part of a sociable cycle of length 3–6.
 
@@ -383,6 +383,8 @@ def is_practical(n: int) -> bool:
     -------
     bool
     """
+    if n <= 0:
+        return False
     if n == 1:
         return True
     if n % 2 != 0 and n != 1:

numclassify-0.4.0/numclassify/_core/exam_types.py

@@ -0,0 +1,388 @@
+"""
+numclassify._core.exam_types
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Number types frequently asked in school/college Python exams (ICSE, CBSE,
+competitive programming, interview prep). All functions registered via @register.
+
+Types added:
+- Strong Number
+- Sunny Number
+- Buzz Number
+- Magic Number
+- Fascinating Number
+- Trimorphic Number
+- Twisted Prime
+- Unique Number (no repeated digits)
+"""
+from __future__ import annotations
+
+import math
+from typing import List
+
+from numclassify._registry import register
+from numclassify._core.primes import is_prime
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+def _digit_sum(n: int) -> int:
+    return sum(int(d) for d in str(abs(n)))
+
+
+def _is_perfect_square_exact(n: int) -> bool:
+    if n < 0:
+        return False
+    r = math.isqrt(n)
+    return r * r == n
+
+
+# ---------------------------------------------------------------------------
+# Strong Number
+# ---------------------------------------------------------------------------
+
+@register(
+    name="Strong",
+    category="digital",
+    oeis="A014080",
+    description=(
+        "A number equal to the sum of the factorials of its digits. "
+        "Also called a factorion. Examples: 1, 2, 145, 40585."
+    ),
+    aliases=["strong_number", "factorion"],
+)
+def is_strong(n: int) -> bool:
+    """Return True if n equals the sum of the factorials of its digits.
+
+    Parameters
+    ----------
+    n : int
+
+    Returns
+    -------
+    bool
+
+    Examples
+    --------
+    >>> is_strong(145)   # 1! + 4! + 5! = 1 + 24 + 120 = 145
+    True
+    >>> is_strong(2)     # 2! = 2
+    True
+    >>> is_strong(40585)
+    True
+    >>> is_strong(100)
+    False
+    """
+    if n <= 0:
+        return False
+    return sum(math.factorial(int(d)) for d in str(n)) == n
+
+
+# ---------------------------------------------------------------------------
+# Sunny Number
+# ---------------------------------------------------------------------------
+
+@register(
+    name="Sunny",
+    category="sequences",
+    oeis="A005563",
+    description=(
+        "A number n where n+1 is a perfect square. "
+        "Examples: 3, 8, 15, 24, 35, 48."
+    ),
+    aliases=["sunny_number"],
+)
+def is_sunny(n: int) -> bool:
+    """Return True if n+1 is a perfect square.
+
+    Parameters
+    ----------
+    n : int
+
+    Returns
+    -------
+    bool
+
+    Examples
+    --------
+    >>> is_sunny(3)    # 3+1 = 4 = 2^2
+    True
+    >>> is_sunny(8)    # 8+1 = 9 = 3^2
+    True
+    >>> is_sunny(24)   # 24+1 = 25 = 5^2
+    True
+    >>> is_sunny(5)    # 5+1 = 6, not a perfect square
+    False
+    """
+    if n <= 0:
+        return False
+    return _is_perfect_square_exact(n + 1)
+
+
+# ---------------------------------------------------------------------------
+# Buzz Number
+# ---------------------------------------------------------------------------
+
+@register(
+    name="Buzz",
+    category="recreational",
+    description=(
+        "A number divisible by 7 or ending in 7 (or both). "
+        "Named after the Buzz game where players say 'buzz' for such numbers."
+    ),
+    aliases=["buzz_number"],
+)
+def is_buzz(n: int) -> bool:
+    """Return True if n is divisible by 7 or ends in the digit 7.
+
+    Parameters
+    ----------
+    n : int
+
+    Returns
+    -------
+    bool
+
+    Examples
+    --------
+    >>> is_buzz(7)    # divisible by 7 and ends in 7
+    True
+    >>> is_buzz(14)   # divisible by 7
+    True
+    >>> is_buzz(17)   # ends in 7
+    True
+    >>> is_buzz(10)
+    False
+    """
+    if n <= 0:
+        return False
+    return n % 7 == 0 or n % 10 == 7
+
+
+# ---------------------------------------------------------------------------
+# Magic Number
+# ---------------------------------------------------------------------------
+
+@register(
+    name="Magic",
+    category="digital",
+    description=(
+        "A number whose repeated digit sum (digital root) equals 1. "
+        "Examples: 1, 10, 19, 28, 100."
+    ),
+    aliases=["magic_number"],
+)
+def is_magic(n: int) -> bool:
+    """Return True if the digital root of n equals 1.
+
+    Repeatedly sum the digits until a single digit remains.
+    If that digit is 1, the number is magic.
+
+    Parameters
+    ----------
+    n : int
+
+    Returns
+    -------
+    bool
+
+    Examples
+    --------
+    >>> is_magic(1)
+    True
+    >>> is_magic(10)   # 1+0 = 1
+    True
+    >>> is_magic(19)   # 1+9=10, 1+0=1
+    True
+    >>> is_magic(28)   # 2+8=10, 1+0=1
+    True
+    >>> is_magic(12)   # 1+2=3 ≠ 1
+    False
+    """
+    if n <= 0:
+        return False
+    while n >= 10:
+        n = _digit_sum(n)
+    return n == 1
+
+
+# ---------------------------------------------------------------------------
+# Fascinating Number
+# ---------------------------------------------------------------------------
+
+@register(
+    name="Fascinating",
+    category="digital",
+    description=(
+        "A 3-digit number n where the concatenation of n, 2n, and 3n "
+        "contains all digits 1-9 exactly once (no zeros, no repeats). "
+        "Examples: 192, 219, 273, 327, 192."
+    ),
+    aliases=["fascinating_number"],
+)
+def is_fascinating(n: int) -> bool:
+    """Return True if n is a fascinating number.
+
+    For a 3-digit n, concatenate str(n) + str(2*n) + str(3*n).
+    The result must use each digit 1-9 exactly once and contain no 0.
+
+    Parameters
+    ----------
+    n : int
+
+    Returns
+    -------
+    bool
+
+    Examples
+    --------
+    >>> is_fascinating(192)   # '192' + '384' + '576' = '192384576'
+    True
+    >>> is_fascinating(273)   # '273' + '546' + '819' = '273546819'
+    True
+    >>> is_fascinating(100)
+    False
+    >>> is_fascinating(123)
+    False
+
+    Notes
+    -----
+    Only 3-digit numbers qualify by definition. Numbers outside [100, 999]
+    always return False.
+    """
+    if n < 100 or n > 999:
+        return False
+    s = str(n) + str(2 * n) + str(3 * n)
+    return len(s) == 9 and set(s) == set('123456789')
+
+
+# ---------------------------------------------------------------------------
+# Trimorphic Number
+# ---------------------------------------------------------------------------
+
+@register(
+    name="Trimorphic",
+    category="digital",
+    description=(
+        "A number whose cube ends with the number itself. "
+        "Examples: 1, 5, 6, 25, 76, 376."
+    ),
+    aliases=["trimorphic_number", "automorphic_cube"],
+)
+def is_trimorphic(n: int) -> bool:
+    """Return True if n^3 ends with n.
+
+    Parameters
+    ----------
+    n : int
+
+    Returns
+    -------
+    bool
+
+    Examples
+    --------
+    >>> is_trimorphic(5)    # 5^3 = 125, ends in 5
+    True
+    >>> is_trimorphic(25)   # 25^3 = 15625, ends in 25
+    True
+    >>> is_trimorphic(376)  # 376^3 = 53157376, ends in 376
+    True
+    >>> is_trimorphic(4)    # 4^3 = 64, does not end in 4
+    False
+
+    Notes
+    -----
+    n <= 0 always returns False.
+    """
+    if n <= 0:
+        return False
+    return str(n ** 3).endswith(str(n))
+
+
+# ---------------------------------------------------------------------------
+# Twisted Prime
+# ---------------------------------------------------------------------------
+
+@register(
+    name="Twisted Prime",
+    category="primes",
+    description=(
+        "A prime number whose digit sum is also prime. "
+        "Examples: 2, 3, 5, 7, 11, 23, 29, 41."
+    ),
+    aliases=["twisted_prime"],
+)
+def is_twisted_prime(n: int) -> bool:
+    """Return True if n is prime and the sum of its digits is also prime.
+
+    Parameters
+    ----------
+    n : int
+
+    Returns
+    -------
+    bool
+
+    Examples
+    --------
+    >>> is_twisted_prime(2)    # prime, digit sum 2 (prime)
+    True
+    >>> is_twisted_prime(23)   # prime, digit sum 5 (prime)
+    True
+    >>> is_twisted_prime(13)   # prime, digit sum 4 (not prime)
+    False
+    >>> is_twisted_prime(29)   # prime, digit sum 11 (prime)
+    True
+    """
+    if not is_prime(n):
+        return False
+    return is_prime(_digit_sum(n))
+
+
+# ---------------------------------------------------------------------------
+# Unique Number
+# ---------------------------------------------------------------------------
+
+@register(
+    name="Unique",
+    category="digital",
+    description=(
+        "A number with no repeated digits. "
+        "Examples: 1, 12, 123, 1234, 9876543210."
+    ),
+    aliases=["unique_number", "unique_digit"],
+)
+def is_unique(n: int) -> bool:
+    """Return True if n has no repeated digits.
+
+    Parameters
+    ----------
+    n : int
+
+    Returns
+    -------
+    bool
+
+    Examples
+    --------
+    >>> is_unique(1234)    # all digits distinct
+    True
+    >>> is_unique(1123)    # digit 1 repeated
+    False
+    >>> is_unique(9876)
+    True
+    >>> is_unique(0)
+    True
+    >>> is_unique(-5)      # negative numbers are not unique
+    False
+
+    Notes
+    -----
+    Single-digit numbers and 0 are always unique.
+    """
+    if n < 0:
+        return False
+    s = str(abs(n))
+    return len(s) == len(set(s))

{numclassify-0.3.2.1 → numclassify-0.4.0}/numclassify/_core/figurate.py

@@ -73,9 +73,7 @@ def is_centered_k_gonal(m: int, k: int) -> bool:
     # k*n^2 - k*n - 2*(m-1) = 0
     # discriminant: k^2 + 4*k*2*(m-1) = k^2 + 8*k*(m-1)
     val = m - 1
-    if 2 * val % k != 0:
-        # Check if 2*(m-1) is divisible by k for integer n check via disc
-        pass  # disc check handles this
+
     disc = k * k + 8 * k * val
     if not _is_perfect_square(disc):
         return False

{numclassify-0.3.2.1 → numclassify-0.4.0}/numclassify/_core/powers.py

@@ -225,7 +225,9 @@ def is_sum_of_three_squares(n: int) -> bool:
     """
     if n < 0:
         return False
-    # Remove factors of 4
+    if n == 0:
+        return True   # 0 = 0^2 + 0^2 + 0^2
+    # Remove factors of 4 (Legendre's three-square theorem)
     while n % 4 == 0:
         n //= 4
     return n % 8 != 7

{numclassify-0.3.2.1 → numclassify-0.4.0}/numclassify/_core/primes.py

@@ -799,8 +799,8 @@ def is_leyland_prime(n: int) -> bool:
     -------
     >>> is_leyland_prime(17)    # 2^3 + 3^2 = 8 + 9 = 17
     True
-    >>> is_leyland_prime(593)   # 2^7 + 7^2 = 128 + 49... wait, that's 177
-    False
+    >>> is_leyland_prime(593)   # 2^9 + 9^2 = 512 + 81 = 593
+    True
     >>> is_leyland_prime(32993) # 2^15 + 15^2 ... verified Leyland prime
     True
 

{numclassify-0.3.2.1 → numclassify-0.4.0}/numclassify/_registry.py

@@ -388,7 +388,7 @@ def find_any_in_range(
     return [n for n in range(start, end + 1) if any(f(n) for f in funcs)]
 
 
-def most_special_in_range(start: int, end: int) -> int:
+def most_special_in_range(start: int, end: int, verbose: bool = False) -> int:
     """Return the integer in ``[start, end]`` with the most ``True`` properties.
 
     Ties are broken by returning the smallest such integer.
@@ -399,6 +399,8 @@ def most_special_in_range(start: int, end: int) -> int:
         Lower bound (inclusive).
     end:
         Upper bound (inclusive).
+    verbose : bool, optional
+        If True, prints progress every 1000 numbers. Default False.
 
     Returns
     -------
@@ -412,9 +414,13 @@ def most_special_in_range(start: int, end: int) -> int:
     """
     best_n = start
     best_count = -1
-    for n in range(start, end + 1):
+    total = end - start + 1
+    for i, n in enumerate(range(start, end + 1)):
         c = count_properties(n)
         if c > best_count:
             best_count = c
             best_n = n
+        if verbose and (i + 1) % 1000 == 0:
+            pct = (i + 1) / total * 100
+            print(f"  most_special_in_range: {i+1}/{total} ({pct:.1f}%) — best so far: {best_n} ({best_count} props)")
     return best_n

{numclassify-0.3.2.1 → numclassify-0.4.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "numclassify"
-version = "0.3.2.1"
+version = "0.4.0"
 description = "The most comprehensive Python library for number classification - 3000+ number types"
 authors = [{name = "Aratrik Ghosh", email = "aratrikghosh2011@gmail.com"}]
 readme = "README.md"
@@ -12,7 +12,7 @@ requires-python = ">=3.8"
 license = {text = "MIT"}
 keywords = ["number-theory", "mathematics", "classification", "armstrong", "prime", "figurate"]
 classifiers = [
-    "Development Status :: 4 - Beta",
+    "Development Status :: 5 - Production/Stable",
     "Intended Audience :: Education",
     "Intended Audience :: Science/Research",
     "Topic :: Scientific/Engineering :: Mathematics",

{numclassify-0.3.2.1 → numclassify-0.4.0}/tests/test_registry.py

@@ -346,3 +346,89 @@ def test_is_keith():
 def test_is_factorial():
     assert is_factorial(24) is True
     assert is_factorial(25) is False
+
+
+# ---------------------------------------------------------------------------
+# Auto-generated crash tests — every registered type, 4 inputs
+# ---------------------------------------------------------------------------
+
+def _get_all_registered_funcs():
+    """Return list of (name, func) for canonical registry entries.
+
+    Samples at most 10 entries from figurate / figurate_centered (since all
+    use the same parametric functions) and all entries from other categories.
+    """
+    from numclassify._registry import REGISTRY, _normalize
+    seen = set()
+    result = []
+    sample = {"figurate", "figurate_centered"}
+    sample_count = {cat: 0 for cat in sample}
+    max_per_cat = 10
+    for key, entry in REGISTRY.items():
+        if key == _normalize(entry.name):
+            if key not in seen:
+                seen.add(key)
+                cat = entry.category
+                if cat in sample:
+                    if sample_count[cat] < max_per_cat:
+                        sample_count[cat] += 1
+                        result.append((entry.name, entry.func))
+                else:
+                    result.append((entry.name, entry.func))
+    return result
+
+
+@pytest.mark.parametrize("name,func", _get_all_registered_funcs())
+def test_no_crash_on_edge_inputs(name, func):
+    """Every registered type must not raise on inputs 0, 1, 2."""
+    for n in [0, 1, 2]:
+        try:
+            result = func(n)
+            assert isinstance(result, bool), (
+                f"{name}({n}) returned {type(result)}, expected bool"
+            )
+        except Exception as e:
+            pytest.fail(f"{name}({n}) raised {type(e).__name__}: {e}")
+
+
+# ---------------------------------------------------------------------------
+# v0.4.0 regression tests
+# ---------------------------------------------------------------------------
+
+def test_classify_has_notable_score():
+    """classify() must include 'notable_score' key."""
+    result = nc.classify(7)
+    assert "notable_score" in result
+    assert isinstance(result["notable_score"], int)
+    assert result["notable_score"] <= result["score"]
+
+
+def test_classify_n1_notable_score_reasonable():
+    """n=1 notable_score must be much less than total score (no figurate inflation)."""
+    result = nc.classify(1)
+    # notable_score excludes figurate and figurate_centered
+    assert result["notable_score"] < 100
+    # Total score will still be large (mathematically correct)
+    assert result["score"] > 1000
+
+
+def test_is_unique_negative():
+    """is_unique must return False for negative integers."""
+    from numclassify._core.exam_types import is_unique
+    assert is_unique(-5) is False
+    assert is_unique(-1) is False
+    assert is_unique(-123) is False
+
+
+def test_is_practical_zero():
+    """is_practical(0) must return False."""
+    from numclassify._core.divisors import is_practical
+    assert is_practical(0) is False
+
+
+def test_no_leaked_names():
+    """Optional, _version, _PackageNotFoundError must not be in dir(nc)."""
+    public_names = [n for n in dir(nc) if not n.startswith("__")]
+    assert "Optional" not in public_names
+    assert "_version" not in public_names
+    assert "_PackageNotFoundError" not in public_names