torch-pyodide 0.0.1__tar.gz

torch_pyodide-0.0.1/PKG-INFO

@@ -0,0 +1,13 @@
+Metadata-Version: 2.4
+Name: torch-pyodide
+Version: 0.0.1
+Summary: Minimal torch-like API for Pyodide using WebGPU runtime bridge.
+Project-URL: Homepage, https://github.com/celsowm/torch-pyodide
+Project-URL: Repository, https://github.com/celsowm/torch-pyodide
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+
+# torch-pyodide Python package
+
+Package distribution for the browser-first `torch` API running on Pyodide + WebGPU.
+

torch_pyodide-0.0.1/README.md

@@ -0,0 +1,4 @@
+# torch-pyodide Python package
+
+Package distribution for the browser-first `torch` API running on Pyodide + WebGPU.
+

torch_pyodide-0.0.1/pyproject.toml

@@ -0,0 +1,17 @@
+[build-system]
+requires = ["setuptools>=68.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "torch-pyodide"
+version = "0.0.1"
+description = "Minimal torch-like API for Pyodide using WebGPU runtime bridge."
+requires-python = ">=3.11"
+readme = "README.md"
+
+[project.urls]
+Homepage = "https://github.com/celsowm/torch-pyodide"
+Repository = "https://github.com/celsowm/torch-pyodide"
+
+[tool.setuptools]
+packages = ["torch"]

torch_pyodide-0.0.1/setup.cfg

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

torch_pyodide-0.0.1/tests/test_tensor_utils.py

@@ -0,0 +1,14 @@
+from torch._tensor import _flatten, _infer_shape, _normalize_shape
+
+
+def test_infer_shape_rectangular():
+    assert _infer_shape([[1, 2], [3, 4]]) == [2, 2]
+
+
+def test_flatten_nested():
+    assert _flatten([[1, 2], [3, 4]]) == [1.0, 2.0, 3.0, 4.0]
+
+
+def test_normalize_shape_sequence():
+    assert _normalize_shape((2, 3)) == [2, 3]
+

torch_pyodide-0.0.1/torch/__init__.py

@@ -0,0 +1,49 @@
+from __future__ import annotations
+
+from typing import Sequence
+
+from ._runtime import _get_runtime, _run_js_awaitable
+from ._tensor import Tensor, ones_from_shape, tensor_from_data, zeros_from_shape
+
+__all__ = ["Tensor", "init", "tensor", "zeros", "ones", "add", "sub", "mul", "div", "matmul", "relu"]
+
+
+def init() -> None:
+    runtime = _get_runtime()
+    _run_js_awaitable(runtime.init())
+
+
+def tensor(data: object, dtype: str = "float32") -> Tensor:
+    return tensor_from_data(data, dtype=dtype)
+
+
+def zeros(shape: int | Sequence[int], dtype: str = "float32") -> Tensor:
+    return zeros_from_shape(shape, dtype=dtype)
+
+
+def ones(shape: int | Sequence[int], dtype: str = "float32") -> Tensor:
+    return ones_from_shape(shape, dtype=dtype)
+
+
+def add(a: Tensor, b: Tensor) -> Tensor:
+    return a.add(b)
+
+
+def sub(a: Tensor, b: Tensor) -> Tensor:
+    return a.sub(b)
+
+
+def mul(a: Tensor, b: Tensor) -> Tensor:
+    return a.mul(b)
+
+
+def div(a: Tensor, b: Tensor) -> Tensor:
+    return a.div(b)
+
+
+def matmul(a: Tensor, b: Tensor) -> Tensor:
+    return a.matmul(b)
+
+
+def relu(x: Tensor) -> Tensor:
+    return x.relu()

torch_pyodide-0.0.1/torch/_runtime.py

@@ -0,0 +1,40 @@
+from __future__ import annotations
+
+from typing import Any
+
+
+RUNTIME_GLOBAL_KEY = "__torch_pyodide_runtime__"
+
+
+def _to_python(value: Any) -> Any:
+    if hasattr(value, "to_py"):
+        return value.to_py()
+    return value
+
+
+def _get_runtime() -> Any:
+    try:
+        from js import globalThis  # type: ignore
+    except Exception as exc:  # pragma: no cover - browser specific
+        raise RuntimeError("This package only runs inside Pyodide.") from exc
+
+    runtime = getattr(globalThis, RUNTIME_GLOBAL_KEY, None)
+    if runtime is None:
+        raise RuntimeError(
+            "Torch runtime bridge not found. Install runtime JS and set "
+            "globalThis.__torch_pyodide_runtime__ before importing torch."
+        )
+    return runtime
+
+
+def _run_js_awaitable(awaitable: Any) -> Any:
+    from pyodide.ffi import can_run_sync, run_sync  # type: ignore
+
+    if not can_run_sync():
+        raise RuntimeError(
+            "Cannot use synchronous torch API: run_sync is unavailable. "
+            "Execute Python through pyodide.runPythonAsync(...) and call "
+            "sync Python functions from JS via callPromising(...)."
+        )
+    return _to_python(run_sync(awaitable))
+

torch_pyodide-0.0.1/torch/_tensor.py

@@ -0,0 +1,158 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Sequence
+
+from ._runtime import _get_runtime, _run_js_awaitable
+
+
+def _js_meta_to_tuple(meta: object) -> tuple[int, list[int], str]:
+    tensor_id = int(getattr(meta, "id"))
+    shape_raw = getattr(meta, "shape")
+    shape = list(shape_raw.to_py() if hasattr(shape_raw, "to_py") else shape_raw)
+    dtype = str(getattr(meta, "dtype"))
+    return tensor_id, shape, dtype
+
+
+@dataclass(slots=True)
+class Tensor:
+    _id: int
+    _shape: list[int]
+    _dtype: str
+
+    @property
+    def shape(self) -> tuple[int, ...]:
+        return tuple(self._shape)
+
+    @property
+    def dtype(self) -> str:
+        return self._dtype
+
+    def add(self, other: "Tensor") -> "Tensor":
+        runtime = _get_runtime()
+        meta = _run_js_awaitable(runtime.add(self._id, other._id))
+        tensor_id, shape, dtype = _js_meta_to_tuple(meta)
+        return Tensor(tensor_id, shape, dtype)
+
+    def mul(self, other: "Tensor") -> "Tensor":
+        runtime = _get_runtime()
+        meta = _run_js_awaitable(runtime.mul(self._id, other._id))
+        tensor_id, shape, dtype = _js_meta_to_tuple(meta)
+        return Tensor(tensor_id, shape, dtype)
+
+    def sub(self, other: "Tensor") -> "Tensor":
+        runtime = _get_runtime()
+        meta = _run_js_awaitable(runtime.sub(self._id, other._id))
+        tensor_id, shape, dtype = _js_meta_to_tuple(meta)
+        return Tensor(tensor_id, shape, dtype)
+
+    def div(self, other: "Tensor") -> "Tensor":
+        runtime = _get_runtime()
+        meta = _run_js_awaitable(runtime.div(self._id, other._id))
+        tensor_id, shape, dtype = _js_meta_to_tuple(meta)
+        return Tensor(tensor_id, shape, dtype)
+
+    def matmul(self, other: "Tensor") -> "Tensor":
+        runtime = _get_runtime()
+        meta = _run_js_awaitable(runtime.matmul(self._id, other._id))
+        tensor_id, shape, dtype = _js_meta_to_tuple(meta)
+        return Tensor(tensor_id, shape, dtype)
+
+    def sum(self) -> "Tensor":
+        runtime = _get_runtime()
+        meta = _run_js_awaitable(runtime.sum(self._id))
+        tensor_id, shape, dtype = _js_meta_to_tuple(meta)
+        return Tensor(tensor_id, shape, dtype)
+
+    def mean(self) -> "Tensor":
+        runtime = _get_runtime()
+        meta = _run_js_awaitable(runtime.mean(self._id))
+        tensor_id, shape, dtype = _js_meta_to_tuple(meta)
+        return Tensor(tensor_id, shape, dtype)
+
+    def relu(self) -> "Tensor":
+        runtime = _get_runtime()
+        meta = _run_js_awaitable(runtime.relu(self._id))
+        tensor_id, shape, dtype = _js_meta_to_tuple(meta)
+        return Tensor(tensor_id, shape, dtype)
+
+    def reshape(self, shape: int | Sequence[int]) -> "Tensor":
+        runtime = _get_runtime()
+        normalized = _normalize_shape(shape)
+        meta = _run_js_awaitable(runtime.reshape(self._id, normalized))
+        tensor_id, out_shape, out_dtype = _js_meta_to_tuple(meta)
+        return Tensor(tensor_id, out_shape, out_dtype)
+
+    @property
+    def T(self) -> "Tensor":
+        runtime = _get_runtime()
+        meta = _run_js_awaitable(runtime.transpose2d(self._id))
+        tensor_id, out_shape, out_dtype = _js_meta_to_tuple(meta)
+        return Tensor(tensor_id, out_shape, out_dtype)
+
+    def to_list(self) -> list[float]:
+        runtime = _get_runtime()
+        result = _run_js_awaitable(runtime.toList(self._id))
+        return list(result)
+
+    def destroy(self) -> None:
+        runtime = _get_runtime()
+        _run_js_awaitable(runtime.destroy(self._id))
+
+
+def _infer_shape(data: object) -> list[int]:
+    if not isinstance(data, list):
+        return []
+    if len(data) == 0:
+        return [0]
+    first_shape = _infer_shape(data[0])
+    for item in data[1:]:
+        if _infer_shape(item) != first_shape:
+            raise ValueError("tensor() expects a rectangular nested list.")
+    return [len(data), *first_shape]
+
+
+def _flatten(data: object) -> list[float]:
+    if isinstance(data, list):
+        out: list[float] = []
+        for item in data:
+            out.extend(_flatten(item))
+        return out
+    return [float(data)]  # type: ignore[arg-type]
+
+
+def _normalize_shape(shape: int | Sequence[int]) -> list[int]:
+    if isinstance(shape, int):
+        if shape < 0:
+            raise ValueError("shape values must be >= 0")
+        return [shape]
+
+    normalized = [int(v) for v in shape]
+    if any(v < 0 for v in normalized):
+        raise ValueError("shape values must be >= 0")
+    return normalized
+
+
+def tensor_from_data(data: object, dtype: str = "float32") -> Tensor:
+    runtime = _get_runtime()
+    shape = _infer_shape(data)
+    flat = _flatten(data)
+    meta = _run_js_awaitable(runtime.tensorFromData(flat, shape, dtype))
+    tensor_id, shape, dtype = _js_meta_to_tuple(meta)
+    return Tensor(tensor_id, shape, dtype)
+
+
+def zeros_from_shape(shape: int | Sequence[int], dtype: str = "float32") -> Tensor:
+    runtime = _get_runtime()
+    normalized = _normalize_shape(shape)
+    meta = _run_js_awaitable(runtime.zeros(normalized, dtype))
+    tensor_id, out_shape, out_dtype = _js_meta_to_tuple(meta)
+    return Tensor(tensor_id, out_shape, out_dtype)
+
+
+def ones_from_shape(shape: int | Sequence[int], dtype: str = "float32") -> Tensor:
+    runtime = _get_runtime()
+    normalized = _normalize_shape(shape)
+    meta = _run_js_awaitable(runtime.ones(normalized, dtype))
+    tensor_id, out_shape, out_dtype = _js_meta_to_tuple(meta)
+    return Tensor(tensor_id, out_shape, out_dtype)

torch_pyodide-0.0.1/torch_pyodide.egg-info/PKG-INFO

@@ -0,0 +1,13 @@
+Metadata-Version: 2.4
+Name: torch-pyodide
+Version: 0.0.1
+Summary: Minimal torch-like API for Pyodide using WebGPU runtime bridge.
+Project-URL: Homepage, https://github.com/celsowm/torch-pyodide
+Project-URL: Repository, https://github.com/celsowm/torch-pyodide
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+
+# torch-pyodide Python package
+
+Package distribution for the browser-first `torch` API running on Pyodide + WebGPU.
+

torch_pyodide-0.0.1/torch_pyodide.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+README.md
+pyproject.toml
+tests/test_tensor_utils.py
+torch/__init__.py
+torch/_runtime.py
+torch/_tensor.py
+torch_pyodide.egg-info/PKG-INFO
+torch_pyodide.egg-info/SOURCES.txt
+torch_pyodide.egg-info/dependency_links.txt
+torch_pyodide.egg-info/top_level.txt

torch_pyodide-0.0.1/torch_pyodide.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

torch_pyodide-0.0.1/torch_pyodide.egg-info/top_level.txt

@@ -0,0 +1 @@
+torch