numclassify 0.4.0__tar.gz → 0.4.1__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: numclassify
-Version: 0.4.0
+Version: 0.4.1
 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
@@ -67,9 +67,15 @@ import numclassify as nc
 nc.is_prime(17)       # True
 nc.is_perfect(28)     # True
 
-# Classify a single number — returns number, true properties, and a score
+# Classify a single number
 nc.classify(1729)
-# {'number': 1729, 'true_properties': ['Taxicab', 'Carmichael', ...], 'score': 22}
+# {
+#   'number': 1729,
+#   'score': 22,            # total true properties (incl. figurate)
+#   'notable_score': 18,    # score excluding polygonal figurate noise
+#   'true_properties': ['Taxicab', 'Carmichael', ...],
+#   'categories': {'primes': [...], 'sequences': [...], ...}
+# }
 
 # Batch classify
 nc.classify_batch([6, 28, 496])
@@ -79,9 +85,12 @@ nc.find_by_property(start=1, end=1000, Perfect=True)
 # [6, 28, 496]
 
 # Stream over large ranges without loading everything into memory
-for result in nc.stream(1, 1_000_000):
-    if result['score'] > 30:
-        print(result)
+for result in nc.stream(1, 1_000_000, min_score=20):
+    print(result)
+
+# Stream only numbers with a specific property
+for result in nc.stream(1, 10_000, has_property="prime"):
+    print(result)
 
 # All true properties of a number
 nc.get_true_properties(1729)
@@ -131,17 +140,18 @@ numclassify info armstrong
 
 | Category | Count | Examples |
 |---|---|---|
-| Polygonal figurate | ~998 | Triangular, Square, Pentagonal, Chiliagonal |
+| Polygonal figurate | ~1003 | Triangular, Square, Pentagonal, Chiliagonal |
 | Centered polygonal | ~998 | Centered Triangular, Centered Hexagonal |
-| Prime families | 41 | Twin, Mersenne, Sophie Germain, Wilson, Safe |
-| Digital invariants | 10 | Armstrong, Spy, Harshad, Disarium, Happy, Neon |
+| Prime families | 40 | Twin, Mersenne, Sophie Germain, Wilson, Safe |
+| Digital invariants | 13 | Armstrong, Spy, Harshad, Disarium, Happy, Neon |
 | Divisor-based | 27 | Perfect, Abundant, Weird, Amicable, Practical |
-| Sequences | 15 | Fibonacci, Lucas, Catalan, Bell, Padovan |
+| Sequences | 16 | Fibonacci, Lucas, Catalan, Bell, Padovan |
 | Powers | 13 | Perfect Square, Taxicab, Sum of Two Squares |
 | Number theory | 14 | Evil, Carmichael, Keith, Autobiographical |
 | Combinatorial | 10 | Factorial, Primorial, Subfactorial |
-| Recreational | 5 | Kaprekar, Automorphic, Palindrome |
-| **Total** | **3000+** | |
+| Recreational | 6 | Kaprekar, Automorphic, Palindrome |
+| Exam types | 8 | Armstrong, Strong, Sunny, Buzz, Magic, Unique |
+| **Total** | **2140+** | |
 
 ---
 
@@ -169,18 +179,19 @@ See [`examples/`](examples/) for runnable scripts covering all major features.
 
 | Function | Description |
 |---|---|
-| `classify(n)` | Returns `{number, true_properties, score}` |
+| `classify(n)` | Returns `{number, score, notable_score, true_properties, categories}` |
 | `classify_batch(numbers)` | Classify a list; returns list of dicts |
 | `random_number(max_n)` | Classify a randomly selected number |
 | `find_by_property(start, end, **filters)` | Numbers in range matching property filters |
-| `stream(start, end)` | Generator — memory-safe range classification |
+| `stream(start, end, min_score, has_property)` | Generator — memory-safe range classification |
 | `get_all_properties(n)` | Dict of every type mapped to True/False |
 | `get_true_properties(n)` | List of True property names only |
 | `print_properties(n)` | Pretty-print property table to stdout |
 | `count_properties(n)` | Count of True properties |
-| `most_special_in_range(lo, hi)` | Number in range with the most True properties |
-| `find_in_range(fn, lo, hi)` | Numbers where `fn` returns True |
-| `find_all_in_range(lo, hi)` | Dict mapping each number to its true properties |
+| `most_special_in_range(lo, hi, verbose)` | Number in range with the most True properties |
+| `find_in_range(fn, lo, hi)` | Numbers where callable `fn` returns True |
+| `find_any_in_range(predicates, lo, hi)` | Integers in range satisfying at least one predicate |
+| `find_all_in_range(predicates, lo, hi)` | Integers in range satisfying all predicates |
 | `register` | Decorator to add custom number types |
 | `is_prime(n)` | Convenience boolean |
 | `is_armstrong(n)` | Convenience boolean |

{numclassify-0.4.0 → numclassify-0.4.1}/README.md

@@ -39,9 +39,15 @@ import numclassify as nc
 nc.is_prime(17)       # True
 nc.is_perfect(28)     # True
 
-# Classify a single number — returns number, true properties, and a score
+# Classify a single number
 nc.classify(1729)
-# {'number': 1729, 'true_properties': ['Taxicab', 'Carmichael', ...], 'score': 22}
+# {
+#   'number': 1729,
+#   'score': 22,            # total true properties (incl. figurate)
+#   'notable_score': 18,    # score excluding polygonal figurate noise
+#   'true_properties': ['Taxicab', 'Carmichael', ...],
+#   'categories': {'primes': [...], 'sequences': [...], ...}
+# }
 
 # Batch classify
 nc.classify_batch([6, 28, 496])
@@ -51,9 +57,12 @@ nc.find_by_property(start=1, end=1000, Perfect=True)
 # [6, 28, 496]
 
 # Stream over large ranges without loading everything into memory
-for result in nc.stream(1, 1_000_000):
-    if result['score'] > 30:
-        print(result)
+for result in nc.stream(1, 1_000_000, min_score=20):
+    print(result)
+
+# Stream only numbers with a specific property
+for result in nc.stream(1, 10_000, has_property="prime"):
+    print(result)
 
 # All true properties of a number
 nc.get_true_properties(1729)
@@ -103,17 +112,18 @@ numclassify info armstrong
 
 | Category | Count | Examples |
 |---|---|---|
-| Polygonal figurate | ~998 | Triangular, Square, Pentagonal, Chiliagonal |
+| Polygonal figurate | ~1003 | Triangular, Square, Pentagonal, Chiliagonal |
 | Centered polygonal | ~998 | Centered Triangular, Centered Hexagonal |
-| Prime families | 41 | Twin, Mersenne, Sophie Germain, Wilson, Safe |
-| Digital invariants | 10 | Armstrong, Spy, Harshad, Disarium, Happy, Neon |
+| Prime families | 40 | Twin, Mersenne, Sophie Germain, Wilson, Safe |
+| Digital invariants | 13 | Armstrong, Spy, Harshad, Disarium, Happy, Neon |
 | Divisor-based | 27 | Perfect, Abundant, Weird, Amicable, Practical |
-| Sequences | 15 | Fibonacci, Lucas, Catalan, Bell, Padovan |
+| Sequences | 16 | Fibonacci, Lucas, Catalan, Bell, Padovan |
 | Powers | 13 | Perfect Square, Taxicab, Sum of Two Squares |
 | Number theory | 14 | Evil, Carmichael, Keith, Autobiographical |
 | Combinatorial | 10 | Factorial, Primorial, Subfactorial |
-| Recreational | 5 | Kaprekar, Automorphic, Palindrome |
-| **Total** | **3000+** | |
+| Recreational | 6 | Kaprekar, Automorphic, Palindrome |
+| Exam types | 8 | Armstrong, Strong, Sunny, Buzz, Magic, Unique |
+| **Total** | **2140+** | |
 
 ---
 
@@ -141,18 +151,19 @@ See [`examples/`](examples/) for runnable scripts covering all major features.
 
 | Function | Description |
 |---|---|
-| `classify(n)` | Returns `{number, true_properties, score}` |
+| `classify(n)` | Returns `{number, score, notable_score, true_properties, categories}` |
 | `classify_batch(numbers)` | Classify a list; returns list of dicts |
 | `random_number(max_n)` | Classify a randomly selected number |
 | `find_by_property(start, end, **filters)` | Numbers in range matching property filters |
-| `stream(start, end)` | Generator — memory-safe range classification |
+| `stream(start, end, min_score, has_property)` | Generator — memory-safe range classification |
 | `get_all_properties(n)` | Dict of every type mapped to True/False |
 | `get_true_properties(n)` | List of True property names only |
 | `print_properties(n)` | Pretty-print property table to stdout |
 | `count_properties(n)` | Count of True properties |
-| `most_special_in_range(lo, hi)` | Number in range with the most True properties |
-| `find_in_range(fn, lo, hi)` | Numbers where `fn` returns True |
-| `find_all_in_range(lo, hi)` | Dict mapping each number to its true properties |
+| `most_special_in_range(lo, hi, verbose)` | Number in range with the most True properties |
+| `find_in_range(fn, lo, hi)` | Numbers where callable `fn` returns True |
+| `find_any_in_range(predicates, lo, hi)` | Integers in range satisfying at least one predicate |
+| `find_all_in_range(predicates, lo, hi)` | Integers in range satisfying all predicates |
 | `register` | Decorator to add custom number types |
 | `is_prime(n)` | Convenience boolean |
 | `is_armstrong(n)` | Convenience boolean |

numclassify-0.4.1/docs/api.md

@@ -0,0 +1,141 @@
+# API Reference
+
+## classify(n)
+
+Classifies a single integer. Returns a dict:
+
+```python
+{
+    "number": 1729,
+    "score": 22,             # total true properties (includes all figurate types)
+    "notable_score": 18,     # score excluding polygonal figurate noise — better for display
+    "true_properties": ["Taxicab", "Carmichael", ...],   # sorted by category then name
+    "categories": {
+        "primes": ["Carmichael"],
+        "sequences": ["..."],
+        ...
+    }
+}
+```
+
+`notable_score` excludes `figurate` and `figurate_centered` hits. Use it when displaying
+a score to humans — otherwise n=1 (which is the first k-gonal number for every k) shows
+a score of 2000+.
+
+## classify_batch(numbers)
+
+Classify a list of integers. Returns a list of dicts in the same format as `classify()`.
+
+```python
+nc.classify_batch([6, 28, 496])
+```
+
+## random_number(max_n=10000)
+
+Classify a random integer from 1 to `max_n`.
+
+## find_by_property(start, end, **filters)
+
+Find integers in `[start, end]` matching keyword property filters.
+
+```python
+nc.find_by_property(start=1, end=1000, Perfect=True)
+# [6, 28, 496]
+```
+
+## stream(start, end, min_score=None, has_property=None)
+
+Memory-safe generator over a range. Yields one result dict per integer.
+
+- `min_score` — skip numbers with `notable_score` below this threshold
+- `has_property` — skip numbers that don't have this property as True
+
+```python
+for result in nc.stream(1, 1_000_000, min_score=20):
+    print(result)
+
+for result in nc.stream(1, 10_000, has_property="prime"):
+    print(result)
+```
+
+## get_all_properties(n)
+
+Returns a dict of every registered type mapped to `True` or `False`.
+
+## get_true_properties(n)
+
+Returns a list of only the `True` property names.
+
+## print_properties(n)
+
+Pretty-prints a formatted table of all True properties to stdout.
+
+## count_properties(n)
+
+Returns the count of True properties (equivalent to `score` in `classify()`).
+
+## most_special_in_range(lo, hi, verbose=False)
+
+Returns the integer in `[lo, hi]` with the highest `score`. Pass `verbose=True`
+for progress output on large ranges.
+
+## find_in_range(fn, lo, hi)
+
+Returns all integers in `[lo, hi]` where callable `fn(n)` returns `True`.
+
+```python
+nc.find_in_range(nc.is_prime, 1, 100)
+```
+
+## find_any_in_range(funcs_or_names, start, end)
+
+Returns all integers in `[start, end]` that satisfy **at least one** of the given predicates.
+
+```python
+# Numbers that are prime OR palindrome in 1..100
+nc.find_any_in_range(["prime", "palindrome"], 1, 100)
+
+# Using callables
+nc.find_any_in_range([nc.is_prime, nc.is_armstrong], 1, 500)
+```
+
+## find_all_in_range(funcs_or_names, start, end)
+
+Returns all integers in `[start, end]` that satisfy **every** predicate given.
+
+```python
+# Numbers that are BOTH prime AND palindrome in 1..1000
+nc.find_all_in_range(["prime", "palindrome"], 1, 1000)
+# => [2, 3, 5, 7, 11, 101, 131, 151, ...]
+```
+
+## register
+
+Decorator to add a custom number type. Registered types appear everywhere — `classify()`,
+`find_by_property()`, the CLI, all of it.
+
+```python
+from numclassify import register
+
+@register(name="My Type", category="recreational", oeis="A000000",
+          description="Numbers divisible by 7 starting with 4")
+def is_my_type(n: int) -> bool:
+    return n > 0 and n % 7 == 0 and str(n)[0] == "4"
+```
+
+Parameters:
+
+- `name` — display name (required)
+- `category` — category string (required)
+- `oeis` — OEIS sequence ID, e.g. `"A000040"` (optional)
+- `description` — one-line description (optional)
+
+## Convenience booleans
+
+```python
+nc.is_prime(17)       # True
+nc.is_armstrong(153)  # True
+nc.is_perfect(28)     # True
+```
+
+These are thin wrappers around the registered functions, exported for direct use.

numclassify-0.4.1/docs/changelog.md

@@ -0,0 +1,124 @@
+# Changelog
+
+All notable changes to numclassify are documented here.
+Format: [Keep a Changelog](https://keepachangelog.com/en/1.0.0/) — [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+---
+
+## [0.4.1] - 2026-06-14
+
+### Fixed
+- `is_achilles(1)` now returns `False`. Previously returned `True` because
+  `_is_perfect_power(1)` incorrectly returned `False` (1 = 1² is a perfect power).
+  First Achilles number is 72, per OEIS A052486.
+- `stream(min_score=N)` now filters on `notable_score` instead of raw `score`.
+  Previously, figurate inflation caused almost all numbers to pass any threshold.
+- `is_spy(0)` now returns `False`. Spy numbers are defined for positive integers only.
+- Playground version badge now always shows live installed version from PyPI
+  instead of the hardcoded version in the HTML source.
+- Fixed `find_any_in_range` and `find_all_in_range` documentation — both functions
+  take a list of predicates as the first argument, not just `(lo, hi)`.
+
+---
+
+## [0.4.0] - 2026-06-13
+
+### Fixed
+- `classify()` now returns `notable_score` — score excluding figurate and centered-figurate hits. Prevents misleading inflation for n=1 (first member of every polygonal sequence).
+- `is_unique(n)` now returns `False` for negative `n`.
+- `is_practical(0)` now returns `False`.
+- Removed leaked internal names (`Optional`, `_version`, `_PackageNotFoundError`) from `dir(numclassify)`.
+- Playground now displays `notable_score` instead of raw score.
+
+### Changed
+- Development status updated to `5 - Production/Stable`.
+
+### Added
+- `SECURITY.md` with vulnerability reporting instructions.
+
+---
+
+## [0.3.3] - 2026-06-13
+
+### Added
+- 8 new exam number types: Strong, Sunny, Buzz, Magic, Fascinating, Trimorphic, Twisted Prime, Unique.
+- `classify()` returns a `categories` dict grouping true properties by category.
+- `stream()` accepts `min_score` and `has_property` filter parameters.
+- `most_special_in_range()` accepts `verbose=True` for progress output.
+- `find_any_in_range()` exported to public API.
+- Auto-generated crash tests (every registered type tested on 0, 1, 2, −1).
+
+### Fixed
+- Infinite loop in `is_sum_of_three_squares(0)`: `while n%4==0` never exits for n=0.
+- Dead `else` branch removed from `classify()`.
+- Fixed wrong docstring example in `is_leyland_prime`.
+
+---
+
+## [0.3.2.1] - 2026-06-12
+
+### Fixed
+- Batch classify rejected comma/space input — changed `type="number"` to `type="text"` with `inputmode="numeric"`.
+- Search autocomplete fallback if Pyodide load fails.
+
+### Changed
+- MkDocs site theme updated to saffron (#FF9933).
+
+---
+
+## [0.3.2] - 2026-06-12
+
+### Added
+- Search autocomplete dropdown.
+- Confetti when score > 50.
+- Keyboard shortcuts: `C`, `S`, `N`, `?`.
+- `prefers-reduced-motion` support.
+
+---
+
+## [0.3.1] - 2026-06-12
+
+### Added
+- Version badge on playground (live from installed package).
+- Category-colored property tags.
+- Batch classify mode.
+- Recent history panel (last 20 numbers).
+- Property tooltips, fuzzy search, search pagination.
+- Number of the Day date picker.
+- Light/dark theme toggle.
+- Download results as JSON.
+
+---
+
+## [0.3.0] - 2026-06-12
+
+### Added
+- Pyodide playground (`docs/playground.html`) — real Python in the browser.
+- Auto GitHub Pages deployment on push to main.
+- Version sync via `importlib.metadata`.
+- PyPI badges in README.
+
+---
+
+## [0.2.1] - 2026-05-11
+
+### Added
+- `examples/` folder with 5 runnable scripts.
+- `CONTRIBUTING.md`.
+- Namespace cleanup.
+
+---
+
+## [0.2.0] - 2026-05
+
+### Added
+- OIDC trusted publishing via GitHub Actions.
+- MkDocs Material documentation deployed to GitHub Pages.
+- `py.typed` marker.
+- 60 hand-written tests.
+
+---
+
+## [0.1.0] - 2026-05
+
+Initial release.

numclassify-0.4.1/docs/cli.md

@@ -0,0 +1,58 @@
+# CLI Reference
+
+Install the package and the `numclassify` command is available immediately.
+
+## check
+
+Classify a single number.
+
+```bash
+numclassify check 1729
+numclassify check 1729 --json     # machine-readable JSON output
+```
+
+## compare
+
+Show properties shared between two numbers and properties unique to each.
+
+```bash
+numclassify compare 6 28
+numclassify compare 6 28 --json
+```
+
+## find
+
+Find numbers of a given type, starting from 1.
+
+```bash
+numclassify find armstrong
+numclassify find prime --limit 20
+```
+
+## range
+
+Classify or filter all integers in a range.
+
+```bash
+numclassify range 1 100
+numclassify range 1 100 --filter prime
+```
+
+## info
+
+Show the definition, category, and OEIS reference for a number type.
+
+```bash
+numclassify info armstrong
+numclassify info taxicab
+```
+
+## list
+
+List all registered number types.
+
+```bash
+numclassify list
+numclassify list --category primes
+numclassify list --category divisors
+```

numclassify-0.4.1/docs/index.md

@@ -0,0 +1,79 @@
+# numclassify
+
+**Given a number, what is it?**
+
+Most number-theory libraries — `labmath`, `eulerlib`, `pyntlib` — compute things: factor integers, find GCDs, generate primes. `numclassify` solves a different problem. Hand it an integer and it tells you every named mathematical type that number belongs to, across 2140+ categories, with zero external dependencies.
+
+```
+153   →  Armstrong, Harshad, Triangular, Abundant, ...
+1729  →  Taxicab (Hardy–Ramanujan), Carmichael, Zeisel, ...
+28    →  Perfect, Triangular, Hexagonal, Semiprime, ...
+```
+
+Try it live: **[numclassify Playground](playground.html)**
+
+---
+
+## Installation
+
+```bash
+pip install numclassify
+```
+
+Python 3.8–3.13. No external dependencies.
+
+---
+
+## Quick example
+
+```python
+import numclassify as nc
+
+nc.classify(1729)
+# {
+#   'number': 1729,
+#   'score': 22,
+#   'notable_score': 18,
+#   'true_properties': ['Taxicab', 'Carmichael', ...],
+#   'categories': {'primes': [...], 'sequences': [...], ...}
+# }
+
+nc.is_prime(17)           # True
+nc.is_perfect(28)         # True
+nc.get_true_properties(6) # ['Perfect', 'Triangular', 'Pronic', ...]
+```
+
+---
+
+## Categories
+
+| Category | Count | Examples |
+|---|---|---|
+| Polygonal figurate | ~1003 | Triangular, Square, Pentagonal |
+| Centered polygonal | ~998 | Centered Triangular, Centered Hexagonal |
+| Prime families | 40 | Twin, Mersenne, Sophie Germain, Safe |
+| Digital invariants | 13 | Armstrong, Harshad, Disarium, Happy |
+| Divisor-based | 27 | Perfect, Abundant, Weird, Practical |
+| Sequences | 16 | Fibonacci, Lucas, Catalan, Bell |
+| Powers | 13 | Perfect Square, Taxicab, Powerful |
+| Number theory | 14 | Evil, Carmichael, Autobiographical |
+| Combinatorial | 10 | Factorial, Primorial, Subfactorial |
+| Recreational | 6 | Kaprekar, Automorphic, Palindrome |
+| Exam types | 8 | Strong, Sunny, Buzz, Magic, Unique |
+
+---
+
+## Add your own types
+
+```python
+from numclassify import register
+
+@register(name="My Type", category="recreational")
+def is_my_type(n: int) -> bool:
+    return n > 0 and n % 7 == 0
+
+import numclassify as nc
+nc.is_my_type(42)  # True — available everywhere immediately
+```
+
+See [API Reference](api.md) for the full function list, or the [CLI Reference](cli.md) for command-line usage.

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

@@ -19,7 +19,7 @@
   <header>
     <button class="theme-toggle" onclick="toggleTheme()" title="Toggle theme"><span id="theme-icon">&#127769;</span></button>
     <div class="logo-badge">numclassify playground</div>
-    <div class="version-badge" id="version-badge" data-version="0.3.2.1">v<span id="version-text">—</span></div>
+    <div class="version-badge" id="version-badge" data-version="0.4.1">v<span id="version-text">—</span></div>
     <h1>Number Intelligence</h1>
     <p class="subtitle">Classify any integer into 3000+ named mathematical types — powered by real Python in your browser.</p>
   </header>

{numclassify-0.4.0 → numclassify-0.4.1}/docs/playground.js

@@ -228,18 +228,12 @@ json.dumps(m)
     console.warn('Could not load category map', e);
   }
 
-  // Fetch version number — prefer local source version as canonical
-  const badge = $('version-badge');
-  const srcVersion = badge ? badge.dataset.version : null;
+  // Fetch version number — always use live installed version from PyPI
   try {
     const pypiVer = await pyodide.runPythonAsync('nc.__version__');
-    // Use the source version (from pyproject.toml) since PyPI may lag behind
-    $('version-text').textContent = srcVersion || pypiVer;
-    if (srcVersion && pypiVer !== srcVersion) {
-      badge.title = 'Source: v' + srcVersion + '  |  PyPI: v' + pypiVer;
-    }
+    $('version-text').textContent = pypiVer;
   } catch(e) {
-    $('version-text').textContent = srcVersion || '?';
+    $('version-text').textContent = '?';
   }
 
   setProgress(100, 'Ready!');
@@ -283,7 +277,7 @@ async function doClassify(n = null) {
     const result = await pyodide.runPythonAsync(`
 import json
 r = nc.classify(${val})
-json.dumps({"number": r["number"], "score": r["score"], "props": r["true_properties"]})
+json.dumps({"number": r["number"], "score": r["notable_score"], "total_score": r["score"], "props": r["true_properties"]})
 `);
     const data = JSON.parse(result);
 
@@ -361,12 +355,12 @@ json.dumps(results)
     results.forEach(r => {
       const tags = r.true_properties.slice(0, 8).map(p => p.replace(/_/g, ' ')).join(', ');
       const more = r.true_properties.length > 8 ? ` +${r.true_properties.length - 8} more` : '';
-      html += `<tr><td class="b-num" onclick="recallHistory(${r.number})">${r.number}</td><td>${r.score}</td><td class="b-tags">${tags}${more}</td></tr>`;
+      html += `<tr><td class="b-num" onclick="recallHistory(${r.number})">${r.number}</td><td>${r.notable_score}</td><td class="b-tags">${tags}${more}</td></tr>`;
     });
     html += '</tbody></table>';
     $('classify-tags').innerHTML = html;
 
-    results.forEach(r => saveHistory({ n: r.number, score: r.score }));
+    results.forEach(r => saveHistory({ n: r.number, score: r.notable_score }));
 
   } catch(e) {
     toast('Error: ' + e.message.slice(0, 80));
@@ -576,7 +570,7 @@ seed = today.year * 10000 + today.month * 100 + today.day
 _random.seed(seed)
 n = _random.randint(1, 9999)
 r = nc.classify(n)
-json.dumps({"number": r["number"], "score": r["score"], "props": r["true_properties"][:12]})
+json.dumps({"number": r["number"], "score": r["notable_score"], "props": r["true_properties"][:12]})
 `);
     const data = JSON.parse(result);
     $('notd-number').textContent = data.number;

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

@@ -201,7 +201,7 @@ def stream(start: int, end: int, min_score: int = 0, has_property: Optional[str]
 
     for n in range(start, end + 1):
         result = classify(n)
-        if result["score"] < min_score:
+        if result["notable_score"] < min_score:
             continue
         if prop_key is not None:
             props = _gap(n)

{numclassify-0.4.0 → numclassify-0.4.1}/numclassify/_core/digital.py

@@ -151,7 +151,7 @@ def is_spy(n: int) -> bool:
     >>> is_spy(124)    # sum=7, product=8  →  False
     False
     """
-    if n < 0:
+    if n <= 0:
         return False
     digits = [int(d) for d in str(n)]
     s = sum(digits)

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

@@ -97,7 +97,9 @@ def _factorization(n: int) -> List[tuple]:
 
 def _is_perfect_power(n: int) -> bool:
     """Return True if n = k^m for some k>1, m>1."""
-    if n <= 1:
+    if n == 1:
+        return True   # 1 = 1^k for any k >= 2
+    if n <= 0:
         return False
     for exp in range(2, n.bit_length() + 1):
         root = round(n ** (1 / exp))

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

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "numclassify"
-version = "0.4.0"
+version = "0.4.1"
 description = "The most comprehensive Python library for number classification - 3000+ number types"
 authors = [{name = "Aratrik Ghosh", email = "aratrikghosh2011@gmail.com"}]
 readme = "README.md"

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

@@ -432,3 +432,41 @@ def test_no_leaked_names():
     assert "Optional" not in public_names
     assert "_version" not in public_names
     assert "_PackageNotFoundError" not in public_names
+
+
+# ---------------------------------------------------------------------------
+# v0.4.1 regression tests
+# ---------------------------------------------------------------------------
+
+
+def test_achilles_not_one():
+    """1 is not an Achilles number — first is 72."""
+    from numclassify._core.divisors import is_achilles
+    assert is_achilles(1) is False
+    assert is_achilles(72) is True
+    assert is_achilles(108) is True
+
+
+def test_perfect_power_one():
+    """1 must be considered a perfect power (1 = 1^2)."""
+    from numclassify._core.divisors import _is_perfect_power
+    assert _is_perfect_power(1) is True
+    assert _is_perfect_power(4) is True
+    assert _is_perfect_power(6) is False
+
+
+def test_stream_min_score_uses_notable():
+    """stream min_score must filter on notable_score, not raw score."""
+    results = list(nc.stream(1, 10, min_score=40))
+    numbers = [r['number'] for r in results]
+    assert 4 not in numbers   # notable_score=35
+    assert 9 not in numbers   # notable_score=38
+    assert 1 in numbers       # notable_score=63
+    assert 2 in numbers       # notable_score=63
+
+
+def test_spy_not_zero():
+    """is_spy(0) must return False."""
+    from numclassify._core.digital import is_spy
+    assert is_spy(0) is False
+    assert is_spy(1) is True

numclassify-0.4.0/docs/api.md

@@ -1,28 +0,0 @@
-# API Reference
-
-## classify(n)
-Returns dict with number, true_properties list, and score.
-
-## classify_batch(numbers)
-Classify a list of integers.
-
-## random_number(max_n=10000)
-Classify a random integer up to max_n.
-
-## find_by_property(start, end, **filters)
-Find numbers matching property filters.
-
-## stream(start, end)
-Memory-safe generator over large ranges.
-
-## register(name, category, ...)
-Decorator to register custom number types. See [examples/custom_type.py](https://github.com/aratrikghosh2011-tech/numclassify/blob/main/examples/custom_type.py).
-
-## Utilities
-- get_all_properties(n)
-- get_true_properties(n)
-- print_properties(n)
-- count_properties(n)
-- most_special_in_range(lo, hi)
-- find_in_range(fn, lo, hi)
-- is_prime(n), is_armstrong(n), is_perfect(n)

numclassify-0.4.0/docs/changelog.md

@@ -1,3 +0,0 @@
-# Changelog
-
-See the full changelog on GitHub.

numclassify-0.4.0/docs/cli.md

@@ -1,22 +0,0 @@
-# CLI Reference
-
-## check
-    numclassify check 1729
-    numclassify check 1729 --json
-
-## compare
-    numclassify compare 6 28
-    numclassify compare 6 28 --json
-
-## find
-    numclassify find armstrong --limit 10
-
-## range
-    numclassify range 1 100 --filter prime
-
-## info
-    numclassify info armstrong
-
-## list
-    numclassify list
-    numclassify list --category primes

numclassify-0.4.0/docs/index.md

@@ -1,23 +0,0 @@
-# numclassify
-
-The most comprehensive Python number classification library - 3000+ types, zero dependencies.
-
-## Installation
-
-    pip install numclassify
-
-## Quick Start
-
-    import numclassify as nc
-    nc.classify(1729)
-    nc.classify_batch([6, 28, 496])
-    nc.find_by_property(start=1, end=1000, Perfect=True)
-    nc.random_number()
-
-## Why numclassify?
-
-- 153: Armstrong, Narcissistic, Harshad, Triangular...
-- 1729: Taxicab, Carmichael, Dodecagonal...
-- 28: Perfect, Triangular, Hexagonal, Keith...
-
-3000+ named number types. Instant lookup. Zero dependencies.