ilang-python 0.1.0__py3-none-macosx_11_0_arm64.whl

ilang/inputs.py

@@ -0,0 +1,66 @@
+from __future__ import annotations
+
+import ctypes
+from typing import Any
+
+from . import ffi
+from .tensor import Device, Tensor, _shape_array
+
+__all__: list[str] = []
+
+
+class _Input:
+    def __init__(self, tensor: ffi._CTensor, keepalive: tuple[Any, ...]) -> None:
+        self.tensor: ffi._CTensor = tensor
+        self.keepalive: tuple[Any, ...] = keepalive
+
+
+def _input(x: Any) -> _Input:
+    if isinstance(x, Tensor):
+        try:
+            import torch
+
+            if isinstance(x._owner, torch.Tensor):
+                inner = _input(x._owner)
+                return _Input(inner.tensor, (x, inner))
+        except ImportError:
+            pass
+        return _Input(x._view(), (x,))
+
+    try:
+        import numpy as np
+
+        if isinstance(x, np.ndarray):
+            if x.dtype != np.float32 or not x.flags.c_contiguous:
+                raise TypeError("NumPy inputs must be float32 and C-contiguous")
+            shape, shape_buf = _shape_array(x.shape)
+            data = x.ctypes.data_as(ctypes.POINTER(ctypes.c_float))
+            return _Input(ffi._CTensor(data, shape_buf, len(shape)), (x, shape_buf))
+    except ImportError:
+        pass
+
+    try:
+        import torch
+
+        if isinstance(x, torch.Tensor):
+            if str(x.dtype) != "torch.float32":
+                raise TypeError("Torch tensors must be float32")
+            if not x.is_contiguous():
+                raise TypeError("Torch tensors must be contiguous")
+            shape, shape_buf = _shape_array(tuple(x.shape))
+            data = ctypes.cast(x.data_ptr(), ctypes.POINTER(ctypes.c_float))
+            return _Input(ffi._CTensor(data, shape_buf, len(shape)), (x, shape_buf))
+    except ImportError:
+        pass
+
+    return _input(Tensor(x))
+
+
+def _inputs(
+    xs: list[Any] | tuple[Any, ...],
+) -> tuple[ctypes.Array[ffi._CTensor], list[_Input]]:
+    views: list[_Input] = [_input(x) for x in xs]
+    arr: ctypes.Array[ffi._CTensor] = (ffi._CTensor * len(views))(
+        *(v.tensor for v in views)
+    )
+    return arr, views

ilang/tensor.py

@@ -0,0 +1,205 @@
+from __future__ import annotations
+
+import ctypes
+from enum import Enum
+from numbers import Real
+from typing import Any
+
+from . import ffi
+
+__all__ = ["Device", "Tensor"]
+
+
+
+class Device(Enum):
+    CPU = "cpu"
+    CUDA = "cuda"
+
+    def _as_ffi(self) -> int:
+        return 0 if self is Device.CPU else 1
+
+    @classmethod
+    def coerce(cls, value: Device | str) -> Device:
+        if isinstance(value, Device):
+            return value
+        name = str(value).lower()
+        if name in {"cpu", "device.cpu"}:
+            return Device.CPU
+        if name in {"cuda", "gpu", "device.cuda"}:
+            return Device.CUDA
+        raise ValueError(f"unknown device {value!r}")
+
+
+def _shape_array(
+    shape: tuple[int, ...],
+) -> tuple[tuple[int, ...], Any]:
+    shape = tuple(int(d) for d in shape)
+    arr: Any = (ctypes.c_size_t * len(shape))(*shape)
+    return shape, arr
+
+
+def _flatten(x: Any) -> tuple[tuple[int, ...], list[float]]:
+    if isinstance(x, Real):
+        return (), [float(x)]
+    if not isinstance(x, (list, tuple)):
+        raise TypeError("Tensor expects a scalar or nested Python lists")
+    if not x:
+        return (0,), []
+
+    child_shape, _data = _flatten(x[0])
+    shape: tuple[int, ...] = (len(x),) + child_shape
+    out: list[float] = []
+    for item in x:
+        item_shape, item_data = _flatten(item)
+        if item_shape != child_shape:
+            raise ValueError("ragged Tensor input")
+        out.extend(item_data)
+    return shape, out
+
+
+def _torch_cuda_empty(shape: tuple[int, ...]) -> Any | None:
+    try:
+        import torch
+
+        if torch.cuda.is_available():
+            return torch.empty(shape, dtype=torch.float32, device="cuda")
+    except ImportError:
+        pass
+    return None
+
+
+def _numel(shape: tuple[int, ...]) -> int:
+    n = 1
+    for dim in shape:
+        n *= dim
+    return n
+
+
+class _OwnedOutputs:
+    def __init__(self, outputs: ctypes.Structure) -> None:
+        self.outputs: ctypes.Structure | None = outputs
+
+    def __del__(self) -> None:
+        outputs = getattr(self, "outputs", None)
+        if outputs is not None:
+            self.outputs = None
+            ffi._core.i_outputs_free(outputs)
+
+
+class _DeviceOwner:
+    def __init__(self, device: Device, data: Any) -> None:
+        self.device = device
+        self.data: Any | None = data
+
+    def __del__(self) -> None:
+        data = getattr(self, "data", None)
+        if data is not None:
+            self.data = None
+            ffi._core.i_free(self.device._as_ffi(), data)
+
+
+class Tensor:
+    def __init__(
+        self,
+        x: Any,
+        shape: tuple[int, ...] | None = None,
+        *,
+        device: Device | str = Device.CPU,
+    ) -> None:
+        device = Device.coerce(device)
+        if shape is None:
+            shape, data = _flatten(x)
+        else:
+            shape = tuple(int(d) for d in shape)
+            data = [float(v) for v in x]
+        self.shape: tuple[int, ...] = tuple(shape)
+        self.device: Device = Device.CPU
+        self._len: int = len(data)
+        self._data: Any = (ctypes.c_float * self._len)(*data)
+        self._shape, self._shape_buf = _shape_array(self.shape)
+        self._owner: _OwnedOutputs | _DeviceOwner | None = None
+        if device is Device.CUDA:
+            moved = self.to(Device.CUDA)
+            self.device = moved.device
+            self._data = moved._data
+            self._owner = moved._owner
+            moved._owner = None
+
+    @classmethod
+    def _from_owned(cls, owner: _OwnedOutputs, index: int) -> Tensor:
+        outputs = owner.outputs
+        assert outputs is not None
+        raw = outputs.tensors[index]
+        self: Tensor = cls.__new__(cls)
+        self.shape = tuple(raw.shape[i] for i in range(raw.rank))
+        self.device = Device.CPU
+        self._len = raw.len
+        self._data = raw.data
+        self._shape, self._shape_buf = _shape_array(self.shape)
+        self._owner = owner
+        return self
+
+    @classmethod
+    def _empty(cls, shape: tuple[int, ...], device: Device | str) -> Tensor:
+        device = Device.coerce(device)
+        self: Tensor = cls.__new__(cls)
+        self.shape = tuple(int(d) for d in shape)
+        self.device = device
+        self._len = _numel(self.shape)
+        self._shape, self._shape_buf = _shape_array(self.shape)
+        if device is Device.CPU:
+            self._data = (ctypes.c_float * self._len)()
+            self._owner = None
+        else:
+            torch_owner = _torch_cuda_empty(self.shape)
+            if torch_owner is not None:
+                self._data = ctypes.cast(torch_owner.data_ptr(), ctypes.POINTER(ctypes.c_float))
+                self._owner = torch_owner
+            else:
+                data = ffi._check_ptr(ffi._core.i_alloc(device._as_ffi(), self._len))
+                self._data = ctypes.cast(data, ctypes.POINTER(ctypes.c_float))
+                self._owner = _DeviceOwner(device, self._data)
+        return self
+
+    @property
+    def data(self) -> list[float]:
+        if self.device is not Device.CPU:
+            raise RuntimeError(
+                "CUDA tensor data is not directly accessible; call .to(Device.CPU) first"
+            )
+        return [self._data[i] for i in range(self._len)]
+
+    def to(self, device: Device | str) -> Tensor:
+        device = Device.coerce(device)
+        if device is self.device:
+            return self
+        out = Tensor._empty(self.shape, device)
+        ffi._check(
+            ffi._core.i_copy(
+                out.device._as_ffi(),
+                out._data,
+                self.device._as_ffi(),
+                self._data,
+                self._len,
+            )
+        )
+        return out
+
+    def _view(self) -> ffi._CTensor:
+        try:
+            import torch
+
+            if isinstance(self._owner, torch.Tensor):
+                data = ctypes.cast(self._owner.data_ptr(), ctypes.POINTER(ctypes.c_float))
+                return ffi._CTensor(data, self._shape_buf, len(self.shape))
+        except ImportError:
+            pass
+        return ffi._CTensor(self._data, self._shape_buf, len(self.shape))
+
+    def __del__(self) -> None:
+        self._owner = None
+
+    def __repr__(self) -> str:
+        if self.device is Device.CPU:
+            return f"Tensor(shape={self.shape}, device=CPU, data={self.data})"
+        return f"Tensor(shape={self.shape}, device=CUDA)"

ilang_python-0.1.0.dist-info/METADATA

@@ -0,0 +1,225 @@
+Metadata-Version: 2.4
+Name: ilang-python
+Version: 0.1.0
+Summary: Python front-end for 𝚒
+License-Expression: Apache-2.0
+License-File: LICENSE
+Classifier: License :: OSI Approved :: Apache Software License
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+Python front-end for 𝚒.
+
+This package exposes 𝚒 components as Python objects. Components compile lazily,
+execute on CPU or CUDA according to their inputs, and interoperate with
+`i.Tensor`, Python scalar/list literals, NumPy `array`s, and Torch `tensor`s.
+
+## Package-style API
+
+```python
+import ilang
+```
+
+Exports:
+
+- `ilang.Component`
+- `ilang.Tensor`
+- `ilang.Device`
+- `ilang.Bench`
+- `ilang.i`
+
+## Preferred "DSL-style" API
+
+The package-exported object `i` acts as a callable "namespace" that enables a
+more compact style of 𝚒 code. When called, it constructs a `Component`, but
+it also re-exposes much of the same package-level API as attributes.
+
+```python
+from ilang import i
+
+i("+i~.")   # <ilang.component.Component object at ...>
+i.Tensor    # <class 'ilang.tensor.Tensor'>
+i.Component # <class 'ilang.component.Component'>
+i.Device    # <enum 'Device'>
+i.I         # mirrors `ilang.Component.I`
+```
+
+## Devices
+
+A `Device` dictates where data lives and where compuation will run.
+
+```python
+i.Device.CPU  # "cpu"
+i.Device.CUDA # "cuda"
+```
+
+## Tensors
+
+`Tensor`s are immutable multidimensional data arrays.
+
+```python
+x = i.Tensor([[1, 2], [3, 4]]) # standard construction does shape-inference on nested list
+x = i.Tensor([1, 2, 3, 4], shape=(2, 2)) # flat data with shape also works
+```
+
+Values are stored as `float32`.
+
+### Attributes
+
+```python
+x.shape  # tuple[int, ...]
+x.device # i.Device.CPU or i.Device.CUDA
+x.data   # list[float] (only available on CPU tensors)
+```
+
+### Methods
+
+```python
+Tensor.to(device i.Device) -> Tensor # gives a new tensor on specified device
+
+# examples:
+x.to(i.Device.CUDA)
+x.to(i.Device.CPU)
+x.to("cuda")
+x.to("cpu")
+```
+
+## Components
+
+`i(expr: str) -> Component` parses one 𝚒 expression.
+
+```python
+f = i("+ij~i") # row-sum
+```
+
+`i.I` is the identity component.
+
+### Component combinators
+
+Components are combined using combinators. Components are immutable, so
+combinators each return a new component.
+
+Method forms:
+
+```python
+f.compose(g) # wires outputs of the right component into inputs of the left component
+f.chain(g)   # wires outputs of the left component into inputs of the right component
+f.fanout(g)  # shares inputs pairwise between two components
+f.pair(g)    # concatenates the inputs and outputs of two components
+f.swap()     # swaps the first two outputs of one component
+```
+
+Operator forms:
+
+```python
+f << g # f.compose(g)
+f >> g # f.chain(g)
+f & g  # f.fanout(g)
+f | g  # f.pair(g)
+~f     # f.swap()
+```
+
+Example:
+
+```python
+matmul = i("ik*kj~ijk") >> i("+ijk~ij")
+```
+
+## Execution
+
+```python
+out = matmul.exec(x, y)
+```
+
+`Component.exec(*inputs: TensorLike, into=None)` executes one component.
+
+where `TensorLike = Tensor | torch.Tensor | numpy.ndarray | nested Python
+sequence`
+
+Execution device is determined by the input devices. All inputs must use the
+same device. NumPy/Torch inputs must be contiguous and of dtype `float32`.
+Python scalars/lists get promoted to CPU `ilang.Tensor`.
+
+### Output type inference
+
+The output container type and device are inferred from the input. For example,
+`f.exec(torch.tensor([...], device="cuda"))` returns an `torch.Tensor` with
+`device="cuda"`. This can be overridden with `into=`: `f.exec(nparray,
+into=i.Tensor)`.
+
+In general, component execution returns `Tuple[Tensor]` but is automatically
+unpacked for single output results.
+
+### Shape inference
+
+`Component.output_shapes(*inputs)` returns one shape tuple per output. Shapes
+are computed from input shapes without executing any kernels.
+
+## Benchmarking
+
+```python
+bench = f.bench([x], n_warmups=10, n_runs=100)
+```
+
+`bench` executes warmup runs, records timed runs, and returns `Bench`.
+
+`Bench` fields:
+
+```python
+bench.mean       # datetime.timedelta
+bench.std        # datetime.timedelta
+bench.n_warmups  # int
+bench.n_runs     # int
+bench.runs       # list[datetime.timedelta]
+```
+
+`repr(bench)` prints a compact human-readable timing summary.
+
+## Errors
+
+Invalid programs, invalid input types, invalid dtypes, non-contiguous arrays,
+device mismatches, and backend failures raise Python exceptions.
+
+Execution requires all inputs to reside on one device. No implicit CPU/CUDA
+input synchronization is performed by `exec`.
+
+CUDA tensor data is not read by `repr` and is not exposed by `.data`. Copy to
+CPU explicitly.
+
+## Examples
+
+Native tensor execution:
+
+```python
+from ilang import i
+
+f = i.i("+ij~ij")
+x = i.Tensor([[1, 2], [3, 4]])
+y = f.exec(x)
+```
+
+CUDA tensor execution:
+
+```python
+x = i.Tensor([[1, 2], [3, 4]]).to("cuda")
+y = f.exec(x)
+z = y.to("cpu")
+```
+
+NumPy execution:
+
+```python
+import numpy as np
+
+x = np.ones((2, 2), dtype=np.float32)
+y = f.exec(x)
+```
+
+Torch CUDA execution:
+
+```python
+import torch
+
+x = torch.ones((2, 2), dtype=torch.float32, device="cuda")
+y = f.exec(x)
+```

ilang_python-0.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+ilang/__init__.py,sha256=mPPSerGXB03-ZnBw73WoAxCr6D8oGOXkpQS3MEbP8Us,407
+ilang/component.py,sha256=Eyj2woo0CdS4PZ-N0cuExeYL2IOu6C0aCqL6B-PjYe4,18629
+ilang/ffi.py,sha256=0dM1Oo4OH-0r_dTbws7RomEJ1bMho9jKUXzPm0dYG6g,5023
+ilang/inputs.py,sha256=pYQgclRFTgVGRleDOUQc_OCDnu-BUfcCX_sgNSbXg3s,2024
+ilang/libi_core.dylib,sha256=X2K5ST24X22ZNmLZuJrkeScI_XBunIcSD7icPcpMaxM,1382848
+ilang/tensor.py,sha256=3SsbDPQNW_ogES4Kz7khxOLKn2mVjrwrAyzD2y206T8,6347
+ilang_python-0.1.0.dist-info/METADATA,sha256=osIqosptFQ5ufBCxGOOeG-gzowSI4x6VcCuoKKgPV_c,5059
+ilang_python-0.1.0.dist-info/RECORD,,
+ilang_python-0.1.0.dist-info/WHEEL,sha256=roArpf_MxwvZELSyjqDlac-lUD5_1viQfLUbIwp-24k,102
+ilang_python-0.1.0.dist-info/licenses/LICENSE,sha256=q2NkHiIxxAaG46uZAoBv9ZQlc9OMZBpKv8djpcX5kmo,11341

ilang_python-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.30.1
+Root-Is-Purelib: false
+Tag: py3-none-macosx_11_0_arm64