sumitENV 0.1.0__tar.gz

sumitenv-0.1.0/PKG-INFO

@@ -0,0 +1,56 @@
+Metadata-Version: 2.4
+Name: sumitENV
+Version: 0.1.0
+Summary: Run sumit403.p4() in an isolated conda environment without crashing your Jupyter kernel
+License: MIT
+Keywords: pytorch,jupyter,conda,isolated,environment,sumit403
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+# Tenv
+
+Run `sumit403.p4()` in a completely isolated conda environment — your Jupyter kernel **never crashes**.
+
+## The Problem
+
+`sumit403.p4()` injects PyTorch code that conflicts with the standard Anaconda environment, causing the kernel to die every time you run it.
+
+## The Solution
+
+**Tenv** runs `p4()` in a separate subprocess inside a dedicated `p4_env` conda environment. Your main kernel is untouched, figures are captured and displayed inline, and you never need to restart.
+
+## Installation
+
+```bash
+pip install Tenv
+```
+
+## Usage
+
+### Step 1 — One-time setup
+
+Run this **once** to create the isolated environment with PyTorch + sumit403:
+
+```python
+from tenv import setup_env
+setup_env()
+```
+
+### Step 2 — Run p4 (every time, no crashes)
+
+```python
+from tenv import run_p4
+run_p4()
+```
+
+That's it. Output streams back to your notebook, matplotlib figures display inline, and your kernel stays alive.
+
+## Requirements
+
+- Anaconda or Miniconda (conda must be on PATH)
+- Python 3.8+

sumitenv-0.1.0/README.md

@@ -0,0 +1,42 @@
+# Tenv
+
+Run `sumit403.p4()` in a completely isolated conda environment — your Jupyter kernel **never crashes**.
+
+## The Problem
+
+`sumit403.p4()` injects PyTorch code that conflicts with the standard Anaconda environment, causing the kernel to die every time you run it.
+
+## The Solution
+
+**Tenv** runs `p4()` in a separate subprocess inside a dedicated `p4_env` conda environment. Your main kernel is untouched, figures are captured and displayed inline, and you never need to restart.
+
+## Installation
+
+```bash
+pip install Tenv
+```
+
+## Usage
+
+### Step 1 — One-time setup
+
+Run this **once** to create the isolated environment with PyTorch + sumit403:
+
+```python
+from tenv import setup_env
+setup_env()
+```
+
+### Step 2 — Run p4 (every time, no crashes)
+
+```python
+from tenv import run_p4
+run_p4()
+```
+
+That's it. Output streams back to your notebook, matplotlib figures display inline, and your kernel stays alive.
+
+## Requirements
+
+- Anaconda or Miniconda (conda must be on PATH)
+- Python 3.8+

sumitenv-0.1.0/pyproject.toml

@@ -0,0 +1,23 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "sumitENV"
+version = "0.1.0"
+description = "Run sumit403.p4() in an isolated conda environment without crashing your Jupyter kernel"
+readme = "README.md"
+license = { text = "MIT" }
+requires-python = ">=3.8"
+keywords = ["pytorch", "jupyter", "conda", "isolated", "environment", "sumit403"]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Intended Audience :: Science/Research",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+]
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["tenv*"]

sumitenv-0.1.0/setup.cfg

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

sumitenv-0.1.0/sumitENV.egg-info/PKG-INFO

@@ -0,0 +1,56 @@
+Metadata-Version: 2.4
+Name: sumitENV
+Version: 0.1.0
+Summary: Run sumit403.p4() in an isolated conda environment without crashing your Jupyter kernel
+License: MIT
+Keywords: pytorch,jupyter,conda,isolated,environment,sumit403
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+# Tenv
+
+Run `sumit403.p4()` in a completely isolated conda environment — your Jupyter kernel **never crashes**.
+
+## The Problem
+
+`sumit403.p4()` injects PyTorch code that conflicts with the standard Anaconda environment, causing the kernel to die every time you run it.
+
+## The Solution
+
+**Tenv** runs `p4()` in a separate subprocess inside a dedicated `p4_env` conda environment. Your main kernel is untouched, figures are captured and displayed inline, and you never need to restart.
+
+## Installation
+
+```bash
+pip install Tenv
+```
+
+## Usage
+
+### Step 1 — One-time setup
+
+Run this **once** to create the isolated environment with PyTorch + sumit403:
+
+```python
+from tenv import setup_env
+setup_env()
+```
+
+### Step 2 — Run p4 (every time, no crashes)
+
+```python
+from tenv import run_p4
+run_p4()
+```
+
+That's it. Output streams back to your notebook, matplotlib figures display inline, and your kernel stays alive.
+
+## Requirements
+
+- Anaconda or Miniconda (conda must be on PATH)
+- Python 3.8+

sumitenv-0.1.0/sumitENV.egg-info/SOURCES.txt

@@ -0,0 +1,9 @@
+README.md
+pyproject.toml
+sumitENV.egg-info/PKG-INFO
+sumitENV.egg-info/SOURCES.txt
+sumitENV.egg-info/dependency_links.txt
+sumitENV.egg-info/top_level.txt
+tenv/__init__.py
+tenv/run_p4.py
+tenv/setup_env.py

sumitenv-0.1.0/sumitENV.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

sumitenv-0.1.0/sumitENV.egg-info/top_level.txt

@@ -0,0 +1 @@
+tenv

sumitenv-0.1.0/tenv/__init__.py

@@ -0,0 +1 @@
+from .run_p4 import run_p4, setup_env

sumitenv-0.1.0/tenv/run_p4.py

@@ -0,0 +1,150 @@
+"""
+run_p4.py — run sumit403.p4() in an isolated conda environment.
+
+Drop this folder next to your Jupyter notebook, then:
+
+    from tenv import run_p4
+    run_p4()
+
+The p4 experiment runs in a separate process — your main kernel never crashes.
+Matplotlib figures are saved as PNG files and displayed inline automatically.
+"""
+
+import subprocess
+import sys
+import os
+import tempfile
+import textwrap
+
+ENV_NAME = "p4_env"
+
+_RUNNER_SCRIPT = textwrap.dedent("""
+import sys
+import os
+
+import matplotlib
+matplotlib.use("Agg")
+
+import matplotlib.pyplot as _plt_orig
+_fig_counter = [0]
+
+_original_show = _plt_orig.show
+def _patched_show(*args, **kwargs):
+    _fig_counter[0] += 1
+    path = os.path.join(FIGURE_DIR, f"p4_figure_{_fig_counter[0]}.png")
+    _plt_orig.savefig(path, bbox_inches="tight", dpi=150)
+    _plt_orig.close("all")
+    print(f"[FIGURE_SAVED] {path}", flush=True)
+
+_plt_orig.show = _patched_show
+
+import sumit403
+import io
+from contextlib import redirect_stdout
+
+buf = io.StringIO()
+with redirect_stdout(buf):
+    sumit403.p4()
+
+injected = buf.getvalue()
+
+lines = injected.splitlines()
+code_lines = []
+capture = False
+for line in lines:
+    if capture:
+        code_lines.append(line)
+    if line.startswith("[DONE]"):
+        capture = True
+
+if code_lines:
+    exec_code = "\\n".join(code_lines)
+    exec(exec_code, {"__name__": "__main__", "FIGURE_DIR": FIGURE_DIR})
+else:
+    print(injected, flush=True)
+""")
+
+
+def setup_env():
+    """
+    One-time setup: create the isolated conda environment and install dependencies.
+    Run this once before calling run_p4().
+    """
+    from tenv.setup_env import setup
+    setup()
+
+
+def run_p4(show_figures=True, figure_dir=None):
+    """
+    Run sumit403.p4() in the isolated 'p4_env' conda environment.
+
+    Parameters
+    ----------
+    show_figures : bool
+        If True (default) and running inside Jupyter, display saved PNG figures inline.
+    figure_dir : str or None
+        Directory to save figure PNGs. Defaults to a temp directory.
+
+    Returns
+    -------
+    list[str]
+        Paths to any figures that were saved.
+    """
+
+    if figure_dir is None:
+        figure_dir = tempfile.mkdtemp(prefix="p4_figures_")
+    else:
+        os.makedirs(figure_dir, exist_ok=True)
+
+    script_code = f"FIGURE_DIR = {repr(figure_dir)}\n" + _RUNNER_SCRIPT
+
+    result = subprocess.run(
+        ["conda", "run", "--no-capture-output", "-n", ENV_NAME,
+         "python", "-c", script_code],
+        capture_output=True,
+        text=True
+    )
+
+    figure_paths = []
+
+    if result.stdout:
+        for line in result.stdout.splitlines():
+            if line.startswith("[FIGURE_SAVED]"):
+                fig_path = line.split("[FIGURE_SAVED]", 1)[1].strip()
+                figure_paths.append(fig_path)
+            else:
+                print(line)
+
+    if result.stderr:
+        filtered = [
+            ln for ln in result.stderr.splitlines()
+            if not ln.strip().startswith("conda") and ln.strip()
+        ]
+        if filtered:
+            print("\n[p4 stderr]", file=sys.stderr)
+            for ln in filtered:
+                print(ln, file=sys.stderr)
+
+    if result.returncode != 0:
+        print(
+            f"\n[ERROR] p4 subprocess exited with code {result.returncode}.\n"
+            "Make sure you ran setup_env() first:\n"
+            "    from tenv import setup_env; setup_env()",
+            file=sys.stderr
+        )
+        return figure_paths
+
+    if show_figures and figure_paths:
+        _display_figures(figure_paths)
+
+    return figure_paths
+
+
+def _display_figures(paths):
+    try:
+        from IPython.display import display, Image
+        for p in paths:
+            if os.path.exists(p):
+                display(Image(filename=p))
+    except ImportError:
+        print(f"[INFO] Figures saved to: {paths}")

sumitenv-0.1.0/tenv/setup_env.py

@@ -0,0 +1,75 @@
+"""
+One-time setup to create the isolated conda environment for sumit403.p4().
+
+Usage:
+    from tenv import setup_env
+    setup_env()
+"""
+
+import subprocess
+import sys
+
+ENV_NAME = "p4_env"
+
+
+def check_conda():
+    try:
+        subprocess.run(
+            ["conda", "info", "--json"],
+            capture_output=True, text=True, check=True
+        )
+        return True
+    except (FileNotFoundError, subprocess.CalledProcessError):
+        return False
+
+
+def env_exists():
+    result = subprocess.run(
+        ["conda", "env", "list"],
+        capture_output=True, text=True
+    )
+    return ENV_NAME in result.stdout
+
+
+def _get_env_python():
+    result = subprocess.run(
+        ["conda", "run", "-n", ENV_NAME, "python", "-c",
+         "import sys; print(sys.executable)"],
+        capture_output=True, text=True, check=True
+    )
+    return result.stdout.strip()
+
+
+def setup():
+    if not check_conda():
+        print("[ERROR] conda not found. Make sure Anaconda/Miniconda is installed and on PATH.")
+        sys.exit(1)
+
+    if env_exists():
+        print(f"[INFO] Environment '{ENV_NAME}' already exists. Skipping creation.")
+    else:
+        print(f"[INFO] Creating conda environment '{ENV_NAME}' with Python 3.10...")
+        subprocess.run(
+            ["conda", "create", "-n", ENV_NAME, "python=3.10", "-y"],
+            check=True
+        )
+        print("[INFO] Environment created.")
+
+    python_bin = _get_env_python()
+
+    print("[INFO] Installing torch (CPU-safe build)...")
+    subprocess.run(
+        [python_bin, "-m", "pip", "install",
+         "torch", "torchvision", "torchaudio",
+         "--index-url", "https://download.pytorch.org/whl/cpu"],
+        check=True
+    )
+
+    print("[INFO] Installing matplotlib and sumit403==0.6...")
+    subprocess.run(
+        [python_bin, "-m", "pip", "install", "matplotlib", "sumit403==0.6"],
+        check=True
+    )
+
+    print(f"\n[DONE] Environment '{ENV_NAME}' is ready.")
+    print("You can now use run_p4() in your notebook without kernel crashes.")