numclassify 0.3.3__tar.gz → 0.4.0__tar.gz

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

@@ -6,6 +6,25 @@ 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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: numclassify
-Version: 0.3.3
+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.3 → numclassify-0.4.0}/numclassify/__init__.py

@@ -115,6 +115,10 @@ def classify(n: int) -> dict:
         "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,
     }
 
@@ -216,6 +220,7 @@ def stream(start: int, end: int, min_score: int = 0, has_property: Optional[str]
 
 __all__ = [
     "__version__",
+    "register",
     "is_prime",
     "is_armstrong",
     "is_perfect",
@@ -237,4 +242,5 @@ __all__ = [
 # Clean up internal names that leak into dir(nc)
 del (_primes, _figurate, _digital, _recreational,
      _divisors, _sequences, _powers, _number_theory,
-     _combinatorial, _exam_types, _core, _registry)
+     _combinatorial, _exam_types, _core, _registry,
+     Optional, _version, _PackageNotFoundError)

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

@@ -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.3.3 → numclassify-0.4.0}/numclassify/_core/exam_types.py

@@ -375,10 +375,14 @@ def is_unique(n: int) -> bool:
     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.3 → 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.3 → numclassify-0.4.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "numclassify"
-version = "0.3.3"
+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.3 → numclassify-0.4.0}/tests/test_registry.py

@@ -353,26 +353,82 @@ def test_is_factorial():
 # ---------------------------------------------------------------------------
 
 def _get_all_registered_funcs():
-    """Return list of (name, func) for every canonical registry entry."""
+    """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):  # canonical key only
+        if key == _normalize(entry.name):
             if key not in seen:
                 seen.add(key)
-                result.append((entry.name, entry.func))
+                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())
-@pytest.mark.parametrize("n", [0, 1, 2, -1])
-def test_no_crash_on_edge_inputs(name, func, n):
-    """Every registered type must not raise on inputs 0, 1, 2, -1."""
-    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}")
+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