numclassify 0.2.0__tar.gz → 0.2.1__tar.gz

{numclassify-0.2.0 → numclassify-0.2.1}/.gitignore

@@ -9,3 +9,4 @@ dist/
 *.egg-info/
 .env
 .venv 
+site/

numclassify-0.2.1/CONTRIBUTING.md

@@ -0,0 +1,71 @@
+# Contributing to numclassify
+
+## Adding a New Number Type
+
+The fastest way to contribute is adding a new number type using the `@register` decorator.
+
+### Step 1 \u2014 Write your function
+
+```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
+```
+
+That's it. Your type is now available via:
+- `nc.get_all_properties(n)`
+- `nc.get_true_properties(n)`
+- `nc.find_in_range(nc.is_my_type, 1, 1000)`
+- `numclassify find my_type` in the CLI
+
+### Step 2 \u2014 Add it to the right module
+
+Place your function in the appropriate file under `numclassify/_core/`:
+
+| Module | Types |
+|---|---|
+| `primes.py` | Prime families |
+| `figurate.py` | Polygonal/figurate numbers |
+| `divisors.py` | Divisor-based (perfect, abundant...) |
+| `digital.py` | Digit-based (Armstrong, Harshad...) |
+| `sequences.py` | Number sequences (Fibonacci, Lucas...) |
+| `powers.py` | Powers and sums |
+| `number_theory.py` | Number theory properties |
+| `combinatorial.py` | Combinatorial numbers |
+| `recreational.py` | Recreational/fun types |
+
+### Step 3 \u2014 Add a test
+
+Add a test in `tests/` following the existing pattern:
+
+```python
+def test_is_my_type():
+    assert nc.is_my_type(7) == True
+    assert nc.is_my_type(1) == False
+```
+
+### Step 4 \u2014 Submit a PR
+
+```bash
+git checkout -b add-my-type
+git add .
+git commit -m "Add My Type number classification"
+git push origin add-my-type
+```
+
+Then open a pull request on GitHub.
+
+## Running Tests
+
+```bash
+cd numclassify
+python -m pytest tests/ -v
+```
+
+## Code Style
+
+- Pure Python, no external dependencies
+- Type hints required on all functions
+- Function name must start with `is_` for boolean classifiers

{numclassify-0.2.0 → numclassify-0.2.1}/PKG-INFO

@@ -1,15 +1,16 @@
 Metadata-Version: 2.4
 Name: numclassify
-Version: 0.2.0
-Summary: The most comprehensive Python library for number classification — 3000+ number types
+Version: 0.2.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
+Project-URL: Documentation, https://aratrikghosh2011-tech.github.io/numclassify/
 Project-URL: Issues, https://github.com/aratrikghosh2011-tech/numclassify/issues
 Author-email: Aratrik Ghosh <aratrikghosh2011@gmail.com>
 License: MIT
 License-File: LICENSE
 Keywords: armstrong,classification,figurate,mathematics,number-theory,prime
-Classifier: Development Status :: 3 - Alpha
+Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Education
 Classifier: Intended Audience :: Science/Research
 Classifier: License :: OSI Approved :: MIT License
@@ -20,6 +21,7 @@ Classifier: Programming Language :: Python :: 3.9
 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 :: Mathematics
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown

numclassify-0.2.1/examples/basic_usage.py

@@ -0,0 +1,6 @@
+import numclassify as nc
+
+print(nc.classify(1729))
+print(nc.classify_batch([6, 28, 496]))
+print(nc.get_true_properties(153))
+print(nc.count_properties(28))

numclassify-0.2.1/examples/custom_type.py

@@ -0,0 +1,12 @@
+from numclassify import register
+import numclassify as nc
+
+# Add a custom number type using the @register decorator
+@register(name="Lucky Seven Multiple", category="recreational")
+def is_lucky_seven_multiple(n: int) -> bool:
+    return n > 0 and n % 7 == 0 and "7" in str(n)
+
+# Now works across the entire API
+print(nc.is_lucky_seven_multiple(77))   # True
+print(nc.is_lucky_seven_multiple(14))   # False
+print("Lucky Seven Multiples under 200:", nc.find_in_range(nc.is_lucky_seven_multiple, 1, 200))

numclassify-0.2.1/examples/find_perfect_numbers.py

@@ -0,0 +1,9 @@
+import numclassify as nc
+
+# Find all perfect numbers under 10000
+perfect = nc.find_by_property(start=1, end=10000, Perfect=True)
+print("Perfect numbers:", perfect)
+
+# Find numbers that are both perfect and odious
+perfect_odious = nc.find_by_property(start=1, end=10000, Perfect=True, Odious=True)
+print("Perfect and Odious:", perfect_odious)

numclassify-0.2.1/examples/random_classify.py

@@ -0,0 +1,6 @@
+import numclassify as nc
+
+# Classify 5 random numbers
+for _ in range(5):
+    result = nc.random_number(max_n=100000)
+    print(f"{result['number']}: {result['score']} properties \u2014 {result['true_properties'][:3]}")

numclassify-0.2.1/examples/stream_large_range.py

@@ -0,0 +1,7 @@
+import numclassify as nc
+
+# Memory-safe streaming over large range
+# Print any number with score > 30
+for result in nc.stream(1, 10000):
+    if result["score"] > 30:
+        print(f"{result['number']}: score={result['score']}, types={result['true_properties'][:5]}")

{numclassify-0.2.0 → numclassify-0.2.1}/numclassify/__init__.py

@@ -24,28 +24,28 @@ Public API
    find_by_property
    stream
 """
-from __future__ import annotations
 
-import random as _random
-from typing import Generator, Iterator, List, Dict, Optional, Any
+from __future__ import annotations
+del annotations
 
-__version__ = "0.2.0"
+__version__ = "0.2.1"
 
 # --- Import all _core submodules so @register decorators fire at import time ---
-from numclassify._core import primes        # noqa: F401
-from numclassify._core import figurate      # noqa: F401
-from numclassify._core import digital       # noqa: F401
-from numclassify._core import recreational  # noqa: F401
-from numclassify._core import divisors      # noqa: F401
-from numclassify._core import sequences     # noqa: F401
-from numclassify._core import powers        # noqa: F401
-from numclassify._core import number_theory # noqa: F401
-from numclassify._core import combinatorial # noqa: F401
+from numclassify._core import primes as _primes        # noqa: F401
+from numclassify._core import figurate as _figurate      # noqa: F401
+from numclassify._core import digital as _digital       # noqa: F401
+from numclassify._core import recreational as _recreational  # noqa: F401
+from numclassify._core import divisors as _divisors      # noqa: F401
+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
 
 # --- Re-export key functions at top level ---
 from numclassify._core.primes import is_prime         # noqa: F401
 from numclassify._core.digital import is_armstrong    # noqa: F401
 from numclassify._core.divisors import is_perfect     # noqa: F401
+from numclassify._registry import register             # noqa: F401
 from numclassify._registry import (                   # noqa: F401
     get_all_properties,
     get_true_properties,
@@ -56,12 +56,25 @@ from numclassify._registry import (                   # noqa: F401
     most_special_in_range,
 )
 
+# ---------------------------------------------------------------------------
+# Dynamic attribute fallback — allows nc.<any_registered_type>() to work
+# ---------------------------------------------------------------------------
+
+def __getattr__(name: str):
+    """Fallback: look up *name* in the global registry as a normalised key."""
+    from numclassify._registry import REGISTRY, _normalize
+
+    key = _normalize(name)
+    if key in REGISTRY:
+        return REGISTRY[key].func
+    raise AttributeError(f"module 'numclassify' has no attribute {name!r}")
+
 
 # ---------------------------------------------------------------------------
 # New features
 # ---------------------------------------------------------------------------
 
-def classify(n: int) -> Dict[str, Any]:
+def classify(n: int) -> dict:
     """
     Returns a summary dict for a single integer.
 
@@ -74,11 +87,10 @@ def classify(n: int) -> Dict[str, Any]:
     }
     """
     raw = get_true_properties(n)
-    # get_true_properties returns dict[str, bool] — extract just the names
     if isinstance(raw, dict):
         true_props = [k for k, v in raw.items() if v]
     else:
-        true_props = list(raw)   # already a list, keep as-is
+        true_props = list(raw)
 
     return {
         "number": n,
@@ -87,25 +99,20 @@ def classify(n: int) -> Dict[str, Any]:
     }
 
 
-def classify_batch(numbers: List[int]) -> List[Dict[str, Any]]:
-    """
-    Accepts a list of ints.
-    Returns a list of classify(n) dicts, one per number, same order.
-    """
+def classify_batch(numbers: list) -> list:
+    """Returns a list of classify(n) dicts, one per number, same order."""
     return [classify(n) for n in numbers]
 
 
-def random_number(max_n: int = 10000) -> Dict[str, Any]:
-    """
-    Picks a random int between 1 and max_n inclusive.
-    Returns the classify(n) result for that number.
-    """
+def random_number(max_n: int = 10000) -> dict:
+    """Picks a random int between 1 and max_n inclusive, returns classify(n)."""
+    import random as _random
     n = _random.randint(1, max_n)
     return classify(n)
 
 
 def find_by_property(start: int = 1, end: int = 1000,
-                     limit: Optional[int] = None, **filters: bool) -> List[int]:
+                     limit: int | None = None, **filters: bool) -> list:
     """
     Query numbers by property values within [start, end].
 
@@ -116,8 +123,7 @@ def find_by_property(start: int = 1, end: int = 1000,
     limit : int, optional
         Stop after finding this many matches.
     **filters : bool
-        Property name → required bool value.
-        Names must match keys in get_all_properties() exactly.
+        Property name to required bool value mapping.
 
     Returns
     -------
@@ -140,7 +146,7 @@ def find_by_property(start: int = 1, end: int = 1000,
     return results
 
 
-def stream(start: int, end: int) -> Generator[Dict[str, Any], None, None]:
+def stream(start: int, end: int):
     """Generator. Yields classify(n) for each n in [start, end]. Memory-safe for large ranges."""
     for n in range(start, end + 1):
         yield classify(n)
@@ -152,7 +158,6 @@ def stream(start: int, end: int) -> Generator[Dict[str, Any], None, None]:
 
 __all__ = [
     "__version__",
-    # existing
     "is_prime",
     "is_armstrong",
     "is_perfect",
@@ -163,10 +168,14 @@ __all__ = [
     "find_all_in_range",
     "count_properties",
     "most_special_in_range",
-    # new
     "classify",
     "classify_batch",
     "random_number",
     "find_by_property",
     "stream",
-]
+]
+
+# Clean up internal names that leak into dir(nc)
+del (_primes, _figurate, _digital, _recreational,
+     _divisors, _sequences, _powers, _number_theory,
+     _combinatorial, _core, _registry)

{numclassify-0.2.0 → numclassify-0.2.1}/numclassify/_registry.py

@@ -123,6 +123,9 @@ def register(
         key = _normalize(name)
         with _REGISTRY_LOCK:
             REGISTRY[key] = entry
+            # Also register under the function's __name__ so
+            # nc.<func_name>() works via __getattr__ fallback
+            REGISTRY[_normalize(func.__name__)] = entry
             for alias in _aliases:
                 REGISTRY[_normalize(alias)] = entry
         return func

{numclassify-0.2.0 → numclassify-0.2.1}/pyproject.toml

@@ -4,15 +4,15 @@ build-backend = "hatchling.build"
 
 [project]
 name = "numclassify"
-version = "0.2.0"
-description = "The most comprehensive Python library for number classification — 3000+ number types"
+version = "0.2.1"
+description = "The most comprehensive Python library for number classification - 3000+ number types"
 authors = [{name = "Aratrik Ghosh", email = "aratrikghosh2011@gmail.com"}]
 readme = "README.md"
 requires-python = ">=3.8"
 license = {text = "MIT"}
 keywords = ["number-theory", "mathematics", "classification", "armstrong", "prime", "figurate"]
 classifiers = [
-    "Development Status :: 3 - Alpha",
+    "Development Status :: 4 - Beta",
     "Intended Audience :: Education",
     "Intended Audience :: Science/Research",
     "Topic :: Scientific/Engineering :: Mathematics",
@@ -22,6 +22,7 @@ classifiers = [
     "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
     "License :: OSI Approved :: MIT License",
     "Operating System :: OS Independent",
 ]
@@ -29,6 +30,7 @@ classifiers = [
 [project.urls]
 Homepage = "https://github.com/aratrikghosh2011-tech/numclassify"
 Repository = "https://github.com/aratrikghosh2011-tech/numclassify"
+Documentation = "https://aratrikghosh2011-tech.github.io/numclassify/"
 Issues = "https://github.com/aratrikghosh2011-tech/numclassify/issues"
 
 [project.scripts]
@@ -36,6 +38,4 @@ numclassify = "numclassify.cli:main"
 
 [tool.hatch.build.targets.wheel]
 packages = ["numclassify"]
-
-[tool.setuptools.package-data]
-numclassify = ["py.typed"]
+include = ["numclassify/py.typed"]