tpy-lang 0.3.0.dev0__py3-none-any.whl

tpyc/_data/lib/tpy/tpy/_builtins/_dict.py

@@ -0,0 +1,151 @@
+# tpy: native_module
+# tpy: cpp_namespace("tpystd::builtins")
+from .._typing import overload, Self, Iterator, Iterable
+from .._bootstrap._decorators import readonly, pure, Own
+from .._core._types import Int32, NativeIterable
+from .._bootstrap._extern import native, cpp_template, native_preserves_refs, builtin_type
+
+
+@builtin_type("builtins.dict_keys")
+@native("tpy::dict_keys_view")
+class dict_keys[K, V](Iterable[K], NativeIterable[K]):
+    @native("tpy::__len__", function=True)
+    @pure
+    @readonly
+    def __len__(self) -> Int32: ...
+
+    @native("tpy::__iter__", function=True)
+    @pure
+    @readonly
+    def __iter__(self) -> Iterator[K]: ...
+
+    @native("contains")
+    @pure
+    @readonly
+    def __contains__(self, key: K) -> bool: ...
+
+
+@builtin_type("builtins.dict_values")
+@native("tpy::dict_values_view")
+class dict_values[K, V](Iterable[V], NativeIterable[V]):
+    @native("tpy::__len__", function=True)
+    @pure
+    @readonly
+    def __len__(self) -> Int32: ...
+
+    @native("tpy::__iter__", function=True)
+    @pure
+    @readonly
+    def __iter__(self) -> Iterator[V]: ...
+
+    @native("contains")
+    @pure
+    @readonly
+    def __contains__(self, value: V) -> bool: ...
+
+
+@builtin_type("builtins.dict_items")
+@native("tpy::dict_items_view")
+class dict_items[K, V](Iterable[tuple[K, V]], NativeIterable[tuple[K, V]]):
+    @native("tpy::__len__", function=True)
+    @pure
+    @readonly
+    def __len__(self) -> Int32: ...
+
+    @native("tpy::__iter__", function=True)
+    @pure
+    @readonly
+    def __iter__(self) -> Iterator[tuple[K, V]]: ...
+
+    @native("contains")
+    @pure
+    @readonly
+    def __contains__(self, item: tuple[K, V]) -> bool: ...
+
+
+@builtin_type("builtins.dict")
+@native("tpy::ordered_map", indirecting=True)
+class dict[K, V](Iterable[K], NativeIterable[K]):
+    @pure
+    @readonly
+    @cpp_template("::tpy::dict_construct<{K}, {V}>({0})")
+    def __init__(self, x: Iterable[Own[tuple[K, V]]]) -> None: ...
+
+    @overload
+    @native("tpy::__iter__", function=True)
+    @pure
+    @readonly
+    def __iter__(self) -> Iterator[K]: ...
+
+    @overload
+    @native("tpy::own_iter_dict", function=True)
+    def __iter__(self: Own[Self]) -> Iterator[Own[K]]: ...
+
+    @native("tpy::__len__", function=True)
+    @pure
+    @readonly
+    def __len__(self) -> Int32: ...
+
+    @native("tpy::__getitem__", function=True)
+    @pure
+    @readonly
+    def __getitem__(self, key: K) -> V: ...
+
+    @native("tpy::__setitem__", function=True)
+    @native_preserves_refs
+    def __setitem__(self, key: K, value: Own[V]) -> None: ...
+
+    @native("tpy::__delitem__", function=True)
+    def __delitem__(self, key: K) -> None: ...
+
+    @native("contains")
+    @pure
+    @readonly
+    def __contains__(self, key: K) -> bool: ...
+
+    @overload
+    @native("tpy::dict_get", function=True)
+    @pure
+    @readonly
+    def get(self, key: K) -> V | None: ...
+
+    @overload
+    @native("tpy::dict_get_default", function=True)
+    @pure
+    @readonly
+    def get(self, key: K, default: V) -> Own[V]: ...
+
+    @overload
+    @native("tpy::dict_pop", function=True)
+    def pop(self, key: K) -> Own[V]: ...
+
+    @overload
+    @native("tpy::dict_pop_default", function=True)
+    def pop(self, key: K, default: V) -> Own[V]: ...
+
+    @native
+    def clear(self) -> None: ...
+
+    @native("tpy::dict_update", function=True)
+    def update(self, other: dict[K, Own[V]]) -> None: ...
+
+    @native("tpy::dict_update", function=True)
+    def __ior__(self, other: dict[K, Own[V]]) -> dict[K, V]: ...
+
+    @native("tpy::dict_setdefault", function=True)
+    def setdefault(self, key: K, default: Own[V]) -> Own[V]: ...
+
+    @native("tpy::dict_keys", function=True)
+    @pure
+    @readonly
+    def keys(self) -> dict_keys[K, V]: ...
+
+    @native("tpy::dict_values", function=True)
+    @pure
+    @readonly
+    def values(self) -> dict_values[K, V]: ...
+
+    @native("tpy::dict_items", function=True)
+    @pure
+    @readonly
+    def items(self) -> dict_items[K, V]: ...

tpyc/_data/lib/tpy/tpy/_builtins/_exceptions.py

@@ -0,0 +1,125 @@
+# tpy: native_module
+# tpy: cpp_namespace("tpystd::builtins")
+from .._bootstrap._decorators import readonly, Own
+from .._bootstrap._extern import native
+from .._core._types import ReturnException, StrView, Throwable
+
+
+# Python exception hierarchy (maps to ::tpy:: runtime structs in core.hpp).
+# The class-level @native is sufficient for both `raise X("msg")` and
+# `e = X("msg")` codegen paths, so __init__ stubs don't need their own
+# @native(..., function=True) annotation.
+#
+# `clone` / `__raise__` are Throwable protocol overrides; the C++ overrides
+# come from TPY_THROWABLE_VIRTUALS in `runtime/cpp/include/tpy/throwable.hpp`
+# applied to every native subclass. Declared once on BaseException so the
+# whole hierarchy inherits the sema-level method visibility.
+@native("tpy::BaseException")
+class BaseException(Throwable):
+    message: str
+
+    def __init__(self, message: str = "") -> None: ...
+
+    def __str__(self) -> StrView: ...
+
+    # Returns Own[Throwable] DELIBERATELY -- do NOT narrow to
+    # Own[BaseException]. Narrowing (so `Box(e.clone())` could be typed
+    # `Box[BaseException]` instead of `Box[Throwable]`) requires covariant
+    # return support, which C++ does not provide for `std::unique_ptr`
+    # (only raw pointers/references; see [class.virtual] and P0670's
+    # rejection). The full exploration -- a sema covariant-return rule + a
+    # `tpy::narrowing_cast<>` codegen bridge -- was built and then dropped:
+    # it forced a divergence between the TPy declaration and the emitted
+    # C++ signature, for what amounts to a naming preference. The
+    # `Box[Throwable]` + virtual-`__raise__` convention (Phase 20; see
+    # `tests/cases/exceptions/box_throwable_preserves_dynamic_type`)
+    # already stores exceptions polymorphically and recovers the concrete
+    # subclass via `raise stored / except ConcreteType`. Revisit only when
+    # TPy gains a backend below the C++ language layer (LLVM / the THIR-MIR
+    # migration) -- see `docs/IR_DESIGN.md` Open Question 10.
+    @readonly
+    def clone(self) -> Own[Throwable]: ...
+
+    @readonly
+    def __raise__(self) -> None: ...
+
+@native("tpy::Exception")
+class Exception(BaseException):
+    def __init__(self, message: str = "") -> None: ...
+
+@native("tpy::ValueError")
+class ValueError(Exception):
+    def __init__(self, message: str = "") -> None: ...
+
+@native("tpy::OSError")
+class OSError(Exception):
+    def __init__(self, message: str = "") -> None: ...
+
+@native("tpy::FileNotFoundError")
+class FileNotFoundError(OSError):
+    def __init__(self, message: str = "") -> None: ...
+
+@native("tpy::AttributeError")
+class AttributeError(Exception):
+    def __init__(self, message: str = "") -> None: ...
+
+@native("tpy::AssertionError")
+class AssertionError(Exception):
+    def __init__(self, message: str = "") -> None: ...
+
+@native("tpy::IndexError")
+class IndexError(Exception):
+    def __init__(self, message: str = "") -> None: ...
+
+@native("tpy::KeyError")
+class KeyError(Exception):
+    def __init__(self, message: str = "") -> None: ...
+
+@native("tpy::ArithmeticError")
+class ArithmeticError(Exception):
+    def __init__(self, message: str = "") -> None: ...
+
+@native("tpy::ZeroDivisionError")
+class ZeroDivisionError(ArithmeticError):
+    def __init__(self, message: str = "") -> None: ...
+
+@native("tpy::OverflowError")
+class OverflowError(ArithmeticError):
+    def __init__(self, message: str = "") -> None: ...
+
+@native("tpy::TypeError")
+class TypeError(Exception):
+    def __init__(self, message: str = "") -> None: ...
+
+@native("tpy::NotImplementedError")
+class NotImplementedError(Exception):
+    def __init__(self, message: str = "") -> None: ...
+
+@native("tpy::RuntimeError")
+class RuntimeError(Exception):
+    def __init__(self, message: str = "") -> None: ...
+
+@native("tpy::MemoryError")
+class MemoryError(Exception):
+    def __init__(self, message: str = "") -> None: ...
+
+@native("tpy::StopIteration")
+class StopIteration(Exception, ReturnException): ...
+
+@native("tpy::StopAsyncIteration")
+class StopAsyncIteration(Exception):
+    def __init__(self, message: str = "") -> None: ...
+
+@native("tpy::TimeoutError")
+class TimeoutError(Exception):
+    def __init__(self, message: str = "") -> None: ...
+
+# CancelledError inherits BaseException directly (not Exception) so
+# `except Exception` does not silently swallow it -- matches CPython 3.8+.
+# Code that wants cleanup-then-propagate on cancellation should use
+# try/finally; code that intentionally consumes cancellation catches it
+# explicitly. Thrown into a coroutine at its resumed-await position when
+# its Task is cancelled. Re-exported by `tpy.task`.
+@native("tpy::CancelledError")
+class CancelledError(BaseException):
+    def __init__(self, message: str = "") -> None: ...