numpy-router 0.1.0__tar.gz

numpy_router-0.1.0/PKG-INFO

@@ -0,0 +1,9 @@
+Metadata-Version: 2.4
+Name: numpy-router
+Version: 0.1.0
+Summary: Runtime NumPy version router with lazy bootstrap and per-version caching.
+Author: Leon
+License: MIT
+Project-URL: Homepage, https://github.com/leomaxwell972/numpy-router
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown

numpy_router-0.1.0/numpy_router/__init__.py

@@ -0,0 +1,70 @@
+# numpy_router/__init__.py
+import os
+
+if os.environ.get("NUMPY_ROUTER_OFF") == "1":
+    # Disable router completely, behave like native numpy
+    import importlib, sys
+    real_numpy = importlib.import_module("numpy")
+    sys.modules["numpy"] = real_numpy
+    sys.modules[__name__] = real_numpy
+    import numpy
+else:
+    
+    import sys
+    import importlib
+    from .core import resolve_numpy_version_for_caller, ensure_numpy_version_path
+    
+    def cache():
+        from .core import CACHE_DIR
+        if not CACHE_DIR.exists():
+            return []
+        return sorted([p.name for p in CACHE_DIR.iterdir() if p.is_dir() and p.name != "_downloads"])
+        # Usage:
+        # import numpy_router
+        # print(numpy_router.cache())
+        # returns list of cached numpy versions
+    
+    def _is_shim(mod):
+        return getattr(mod, "__numpy_router_shim__", False) is True
+    
+    
+    def _bootstrap():
+        from .core import resolve_numpy_version_for_caller, ensure_numpy_version_path
+        import sys as _sys
+        import importlib as _importlib
+    
+        version = resolve_numpy_version_for_caller()
+        base_path = ensure_numpy_version_path(version)
+    
+        if base_path not in _sys.path:
+            _sys.path.insert(0, base_path)
+    
+        # Kill the shim/proxy so importlib doesn't route back through us
+        _sys.modules.pop("numpy", None)
+    
+        real_numpy = _importlib.import_module("numpy")
+    
+        _sys.modules["numpy"] = real_numpy
+        _sys.modules[__name__] = real_numpy
+        return real_numpy
+    
+    
+    
+    def _wrap_shim():
+        mod = sys.modules.get("numpy")
+        if not mod or not _is_shim(mod):
+            return
+    
+        class _ShimProxy:
+            def __getattr__(self, name):
+                real = _bootstrap()
+                return getattr(real, name)
+    
+            def __dir__(self):
+                real = _bootstrap()
+                return dir(real)
+    
+        sys.modules["numpy"] = _ShimProxy()
+    
+    
+    _wrap_shim()

numpy_router-0.1.0/numpy_router/core.py

@@ -0,0 +1,183 @@
+# numpy_router/core.py
+import glob
+import inspect
+import logging
+import os
+import shutil
+import subprocess
+import sys
+import zipfile
+from pathlib import Path
+from typing import Optional
+import __main__
+
+logger = logging.getLogger("numpy_router")
+
+DEFAULT_PRE_2 = "1.26.4"
+DEFAULT_POST_2 = "2.2.0"
+
+CACHE_DIR = Path(os.environ.get("NUMPY_ROUTER_CACHE", Path.home() / ".numpy_router_cache"))
+DOWNLOAD_DIR = CACHE_DIR / "_downloads"
+
+
+def _download_numpy(version: str) -> Path:
+    print(f"[numpy_router] Downloading numpy=={version} ...", flush=True)
+
+    CACHE_DIR.mkdir(parents=True, exist_ok=True)
+    DOWNLOAD_DIR.mkdir(parents=True, exist_ok=True)
+
+    python_exe = sys.executable
+    env = os.environ.copy()
+    env["NUMPY_ROUTER_DISABLE"] = "1"  # if you ever want to use it in __init__, it's there
+
+    cmd = [
+        python_exe,
+        "-m", "pip", "download",
+        f"numpy=={version}",
+        "-d", str(DOWNLOAD_DIR),
+        "--no-deps",
+    ]
+    res = subprocess.run(cmd, capture_output=True, text=True, env=env)
+
+    print(f"[numpy_router] Download complete.", flush=True)
+
+    if res.returncode != 0:
+        raise RuntimeError(
+            f"Failed to download numpy=={version}\n"
+            f"stdout:\n{res.stdout}\n\nstderr:\n{res.stderr}"
+        )
+
+    pattern = DOWNLOAD_DIR / f"numpy-{version}*"
+    matches = glob.glob(str(pattern))
+    if not matches:
+        raise RuntimeError(f"No archive found for numpy=={version} (pattern {pattern})")
+
+    return Path(matches[0])
+
+
+def _extract_archive(archive_path: Path, dest_dir: Path) -> None:
+    s = str(archive_path)
+    if s.endswith((".whl", ".zip")):
+        with zipfile.ZipFile(archive_path, "r") as zf:
+            zf.extractall(dest_dir)
+    else:
+        import tarfile
+        with tarfile.open(archive_path, "r:*") as tf:
+            tf.extractall(dest_dir)
+
+
+def ensure_numpy_version_path(version: str) -> str:
+    target_dir = CACHE_DIR / version
+
+    # Cache hit
+    if target_dir.is_dir() and any(target_dir.iterdir()):
+        print(f"[numpy_router] Using cached numpy=={version}", flush=True)
+        return str(target_dir)
+
+    # Cache miss → fresh download
+    if target_dir.exists():
+        shutil.rmtree(target_dir)
+    target_dir.mkdir(parents=True, exist_ok=True)
+
+    archive_path = _download_numpy(version)
+    print(f"[numpy_router] Extracting numpy=={version} ...", flush=True)
+    _extract_archive(archive_path, target_dir)
+    print(f"[numpy_router] Extraction complete.", flush=True)
+
+    return str(target_dir)
+
+
+
+def _find_requirements_file(root: Path) -> Optional[Path]:
+    req = root / "requirements.txt"
+    if req.is_file():
+        return req
+    matches = list(root.glob("*requirements*.txt"))
+    return matches[0] if matches else None
+
+
+def _read_requirements_numpy(req_file: Path) -> Optional[str]:
+    try:
+        text = req_file.read_text(encoding="utf-8", errors="ignore")
+    except Exception:
+        return None
+    for line in text.splitlines():
+        line = line.strip()
+        if not line or line.startswith("#"):
+            continue
+        if line.lower().startswith("numpy"):
+            return line
+    return None
+
+
+def _pick_version_from_requirement(req: str) -> str:
+    r = req.strip().lower()
+    if "==" in r:
+        after = r.split("==", 1)[1]
+        after = after.split(";", 1)[0].split("[", 1)[0].strip()
+        return after
+    if "<2" in r:
+        return DEFAULT_PRE_2
+    if ">=2" in r or " 2." in r or ">= 2" in r:
+        return DEFAULT_POST_2
+    return DEFAULT_POST_2
+
+
+
+def _find_dist_info_for_package(pkg_name: str) -> Optional[Path]:
+    for p in sys.path:
+        try:
+            base = Path(p)
+            if not base.is_dir():
+                continue
+            for d in base.glob(f"{pkg_name.replace('.', '-')}-*.dist-info"):
+                return d
+        except Exception:
+            pass
+    return None
+
+def _read_metadata_requires_numpy(dist_info: Path) -> Optional[str]:
+    meta = dist_info / "METADATA"
+    if not meta.is_file():
+        return None
+
+    try:
+        text = meta.read_text(encoding="utf-8", errors="ignore")
+    except Exception:
+        return None
+
+    for line in text.splitlines():
+        if line.lower().startswith("requires-dist: numpy"):
+            return line
+    return None
+
+def resolve_numpy_version_for_caller() -> str:
+    forced = os.environ.get("NUMPY_ROUTER_VERSION")
+    if forced:
+        print(f"[numpy_router] Using user-forced version {forced}", flush=True)
+        return forced
+
+    main_file = getattr(__main__, "__file__", None)
+    main_root = Path(main_file).resolve().parent if main_file else None
+
+    # 1) requirements.txt next to main script
+    if main_root:
+        req_file = _find_requirements_file(main_root)
+        if req_file:
+            req_line = _read_requirements_numpy(req_file)
+            if req_line:
+                return _pick_version_from_requirement(req_line)
+
+    # 2) dist-info metadata for the caller package
+    caller_name = Path(main_file).stem if main_file else None
+    if caller_name:
+        dist = _find_dist_info_for_package(caller_name)
+        if dist:
+            req_line = _read_metadata_requires_numpy(dist)
+            if req_line:
+                return _pick_version_from_requirement(req_line)
+
+    # 3) fallback heuristic
+    print(f"[numpy_router] No version info found; guessing {DEFAULT_POST_2}", flush=True)
+    return DEFAULT_POST_2
+

numpy_router-0.1.0/numpy_router.egg-info/PKG-INFO

@@ -0,0 +1,9 @@
+Metadata-Version: 2.4
+Name: numpy-router
+Version: 0.1.0
+Summary: Runtime NumPy version router with lazy bootstrap and per-version caching.
+Author: Leon
+License: MIT
+Project-URL: Homepage, https://github.com/leomaxwell972/numpy-router
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown

numpy_router-0.1.0/numpy_router.egg-info/SOURCES.txt

@@ -0,0 +1,9 @@
+README.md
+numpy_router.pth
+pyproject.toml
+numpy_router/__init__.py
+numpy_router/core.py
+numpy_router.egg-info/PKG-INFO
+numpy_router.egg-info/SOURCES.txt
+numpy_router.egg-info/dependency_links.txt
+numpy_router.egg-info/top_level.txt

numpy_router-0.1.0/numpy_router.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

numpy_router-0.1.0/numpy_router.egg-info/top_level.txt

@@ -0,0 +1 @@
+numpy_router

numpy_router-0.1.0/numpy_router.pth

@@ -0,0 +1 @@
+import sys, types, importlib; m = types.ModuleType("numpy"); m.__dict__["__numpy_router_shim__"] = True; sys.modules["numpy"] = m; importlib.import_module("numpy_router")

numpy_router-0.1.0/pyproject.toml

@@ -0,0 +1,26 @@
+[build-system]
+requires = ["setuptools>=61"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "numpy-router"
+version = "0.1.0"
+description = "Runtime NumPy version router with lazy bootstrap and per-version caching."
+readme = "README.md"
+requires-python = ">=3.8"
+license = { text = "MIT" }
+authors = [
+    { name = "Leon" }
+]
+
+dependencies = []
+
+[project.urls]
+Homepage = "https://github.com/leomaxwell972/numpy-router"
+
+[tool.setuptools]
+packages = ["numpy_router"]
+
+[tool.setuptools.data-files]
+"site-packages" = ["numpy_router.pth"]
+

numpy_router-0.1.0/setup.cfg

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