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

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

@@ -0,0 +1,97 @@
+# tpy: native_module
+# tpy: cpp_namespace("tpystd::builtins")
+from .._typing import overload, Literal
+from .._bootstrap._extern import native, builtin_type
+from .._core._types import Int32
+
+
+@builtin_type("builtins.TextIO")
+@native("tpy::TextFile")
+class TextIO:
+    @native("read")
+    def read(self) -> str: ...
+
+    @native("write")
+    def write(self, text: str) -> Int32: ...
+
+    @native("readline")
+    def readline(self) -> str: ...
+
+    @native("readlines")
+    def readlines(self) -> list[str]: ...
+
+    @native("flush")
+    def flush(self) -> None: ...
+
+    @native("close")
+    def close(self) -> None: ...
+
+    @native("__enter__")
+    def __enter__(self) -> TextIO: ...
+
+    @native("__exit__")
+    def __exit__(self, exc_type, exc_val, exc_tb) -> None: ...
+
+
+@builtin_type("builtins.BinaryIO")
+@native("tpy::BinaryFile")
+class BinaryIO:
+    @native("read")
+    def read(self) -> bytes: ...
+
+    @native("readline")
+    def readline(self) -> bytes: ...
+
+    @native("readlines")
+    def readlines(self) -> list[bytes]: ...
+
+    @native("write")
+    def write(self, data: bytes) -> Int32: ...
+
+    @native("close")
+    def close(self) -> None: ...
+
+    @native("__enter__")
+    def __enter__(self) -> BinaryIO: ...
+
+    @native("__exit__")
+    def __exit__(self, exc_type, exc_val, exc_tb) -> None: ...
+
+
+@overload
+@native("tpy::builtin_open")
+def open(path: str) -> TextIO: ...
+
+@overload
+@native("tpy::builtin_open_mode")
+def open(path: str, mode: Literal[
+    "r", "w", "a", "x", "rt", "wt", "at", "xt",
+    "r+", "w+", "a+", "x+", "r+t", "w+t", "a+t", "x+t", "rt+", "wt+", "at+", "xt+",
+]) -> TextIO: ...
+
+@overload
+@native("tpy::builtin_open_binary")
+def open(path: str, mode: Literal[
+    "rb", "wb", "ab", "xb",
+    "r+b", "w+b", "a+b", "x+b", "rb+", "wb+", "ab+", "xb+",
+]) -> BinaryIO: ...
+
+@overload
+@native("tpy::builtin_open_mode")
+def open(path: str, mode: str) -> TextIO: ...
+
+@overload
+@native("tpy::builtin_open")
+def open_text(path: str) -> TextIO: ...
+
+@overload
+@native("tpy::builtin_open_mode")
+def open_text(path: str, mode: str) -> TextIO: ...
+
+@overload
+@native("tpy::builtin_open_binary")
+def open_binary(path: str) -> BinaryIO: ...
+
+@overload
+@native("tpy::builtin_open_binary")
+def open_binary(path: str, mode: str) -> BinaryIO: ...

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

@@ -0,0 +1,127 @@
+# 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, Equatable, Comparable, NativeIterable, NativeRangeConstructible, Spannable
+from .._core._containers import Span
+from .._bootstrap._extern import native, cpp_template, native_preserves_refs, builtin_type
+
+
+@builtin_type("builtins.list")
+@native("std::vector", indirecting=True)
+class list[T](Iterable[T], NativeIterable[T], NativeRangeConstructible[T], Spannable[T]):
+    @pure
+    @readonly
+    @cpp_template("::tpy::construct<std::vector<{T}>>({0})")
+    def __init__(self, x: Iterable[Own[T]]) -> None: ...
+
+    @overload
+    @native("tpy::__iter__", function=True)
+    @pure
+    @readonly
+    def __iter__(self) -> Iterator[T]: ...
+
+    @overload
+    @native("tpy::own_iter", function=True)
+    def __iter__(self: Own[Self]) -> Iterator[Own[T]]: ...
+
+    @native("tpy::__len__", function=True)
+    @pure
+    @readonly
+    def __len__(self) -> Int32: ...
+
+    @native("push_back")
+    def append(self, value: Own[T]) -> None: ...
+
+    @overload
+    @native("tpy::pop_back", function=True)
+    def pop(self) -> Own[T]: ...
+
+    @overload
+    @native("tpy::list_pop_at", function=True)
+    def pop(self, index: Int32) -> Own[T]: ...
+
+    @native
+    def clear(self) -> None: ...
+
+    @cpp_template("{self}[{0}]")
+    @pure
+    @readonly
+    def unchecked_get(self, index: Int32) -> T: ...
+
+    @overload
+    @native("tpy::__getitem__", function=True)
+    @pure
+    @readonly
+    def __getitem__(self, index: Int32) -> T: ...
+
+    @overload
+    @cpp_template("::tpy::list_slice({self}, {0})")
+    @pure
+    @readonly
+    def __getitem__(self, index: basic_slice) -> Span[T]: ...
+
+    @overload
+    @cpp_template("::tpy::list_stepped_slice({self}, {0})")
+    @pure
+    @readonly
+    def __getitem__(self, index: slice) -> Own[list[T]]: ...
+
+    @overload
+    @native("tpy::__setitem__", function=True)
+    @native_preserves_refs
+    def __setitem__(self, index: Int32, value: Own[T]) -> None: ...
+
+    @overload
+    @native("tpy::list_set_slice", function=True)
+    def __setitem__(self, index: basic_slice, value: Iterable[Own[T]]) -> None: ...
+
+    @overload
+    @native("tpy::list_set_stepped_slice", function=True)
+    def __setitem__(self, index: slice, value: Iterable[Own[T]]) -> None: ...
+
+    @native("tpy::__delitem__", function=True)
+    def __delitem__(self, index: Int32) -> None: ...
+
+    @native("tpy::list_insert", function=True)
+    def insert(self, index: Int32, value: Own[T]) -> None: ...
+
+    @native("tpy::list_remove", function=True)
+    def remove[T: Equatable](self, value: T) -> None: ...
+
+    @native("tpy::list_extend", function=True)
+    def extend(self, other: Iterable[Own[T]]) -> None: ...
+
+    @native("tpy::list_index", function=True)
+    @pure
+    @readonly
+    def index[T: Equatable](self, value: T) -> Int32: ...
+
+    @native("tpy::list_count", function=True)
+    @pure
+    @readonly
+    def count[T: Equatable](self, value: T) -> Int32: ...
+
+    @native("tpy::list_reverse", function=True)
+    def reverse(self) -> None: ...
+
+    @cpp_template("std::stable_sort({self}.begin(), {self}.end())")
+    def sort[T: Comparable](self) -> None: ...
+
+    @native("tpy::list_copy", function=True)
+    @pure
+    @readonly
+    def copy(self) -> Own[list[T]]: ...
+
+    @native("tpy::list_concat", function=True)
+    @pure
+    @readonly
+    def __add__(self, other: list[T]) -> list[T]: ...
+
+    @native("tpy::list_extend", function=True)
+    def __iadd__(self, other: Iterable[Own[T]]) -> list[T]: ...
+
+    @native("tpy::as_span", function=True)
+    @pure
+    @readonly
+    def __span__(self) -> Span[readonly[T]]: ...

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

@@ -0,0 +1,52 @@
+# tpy: native_module
+# tpy: cpp_namespace("tpystd::builtins")
+from .._typing import overload, Sized, Iterator, Iterable
+from .._bootstrap._decorators import readonly, pure, error_return, Own
+from .._core._types import (
+    Int8, Int16, Int32, Int64, UInt8, UInt16, UInt32, UInt64,
+    Char, String, StrView, Float32, AnyFixedInt,
+    Hashable, Representable, Stringable, NativeIterable, Truthy, Comparable, Equatable,
+)
+from .._bootstrap._extern import native, cpp_template, builtin_type
+
+# Range type and range() function
+@builtin_type("builtins.Range")
+@native("tpy::Range")
+class Range[T](NativeIterable[T], Iterable[T]):
+    @native("tpy::__iter__", function=True)
+    @readonly
+    @pure
+    def __iter__(self) -> Iterator[T]: ...
+
+
+@overload
+@cpp_template("::tpy::Range<{T}>({0})")
+@readonly
+@pure
+def range[T: AnyFixedInt](stop: T) -> Range[T]: ...
+@overload
+@cpp_template("::tpy::Range<{T}>({0}, {1})")
+@readonly
+@pure
+def range[T: AnyFixedInt](start: T, stop: T) -> Range[T]: ...
+@overload
+@cpp_template("::tpy::Range<{T}>({0}, {1}, {2})")
+@readonly
+@pure
+def range[T: AnyFixedInt](start: T, stop: T, step: T) -> Range[T]: ...
+
+@overload
+@cpp_template("::tpy::Range<::tpy::BigInt>({0})")
+@readonly
+@pure
+def range(stop: int) -> Range[int]: ...
+@overload
+@cpp_template("::tpy::Range<::tpy::BigInt>({0}, {1})")
+@readonly
+@pure
+def range(start: int, stop: int) -> Range[int]: ...
+@overload
+@cpp_template("::tpy::Range<::tpy::BigInt>({0}, {1}, {2})")
+@readonly
+@pure
+def range(start: int, stop: int, step: int) -> Range[int]: ...

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

@@ -0,0 +1,139 @@
+# 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, builtin_type
+
+
+@builtin_type("builtins.set")
+@native("tpy::ordered_set", indirecting=True)
+class set[T](Iterable[T], NativeIterable[T]):
+    @pure
+    @readonly
+    @cpp_template("::tpy::set_construct<{T}>({0})")
+    def __init__(self, x: Iterable[Own[T]]) -> None: ...
+
+    @overload
+    @native("tpy::__iter__", function=True)
+    @pure
+    @readonly
+    def __iter__(self) -> Iterator[T]: ...
+
+    @overload
+    @native("tpy::own_iter_set", function=True)
+    def __iter__(self: Own[Self]) -> Iterator[Own[T]]: ...
+
+    @native("tpy::__len__", function=True)
+    @pure
+    @readonly
+    def __len__(self) -> Int32: ...
+
+    @native("contains")
+    @pure
+    @readonly
+    def __contains__(self, value: T) -> bool: ...
+
+    @native("insert")
+    def add(self, value: Own[T]) -> None: ...
+
+    @native("erase")
+    def discard(self, value: T) -> None: ...
+
+    @native("tpy::set_remove", function=True)
+    def remove(self, value: T) -> None: ...
+
+    @native("tpy::set_pop", function=True)
+    def pop(self) -> Own[T]: ...
+
+    @native
+    def clear(self) -> None: ...
+
+    @native("tpy::set_copy", function=True)
+    @pure
+    @readonly
+    def copy(self) -> Own[set[T]]: ...
+
+    # Set algebra (return new set)
+    @native("tpy::set_union", function=True)
+    @pure
+    @readonly
+    def union(self, other: set[T]) -> Own[set[T]]: ...
+
+    @native("tpy::set_intersection", function=True)
+    @pure
+    @readonly
+    def intersection(self, other: set[T]) -> Own[set[T]]: ...
+
+    @native("tpy::set_difference", function=True)
+    @pure
+    @readonly
+    def difference(self, other: set[T]) -> Own[set[T]]: ...
+
+    @native("tpy::set_symmetric_difference", function=True)
+    @pure
+    @readonly
+    def symmetric_difference(self, other: set[T]) -> Own[set[T]]: ...
+
+    # Set predicates
+    @native("tpy::set_issubset", function=True)
+    @pure
+    @readonly
+    def issubset(self, other: set[T]) -> bool: ...
+
+    @native("tpy::set_issuperset", function=True)
+    @pure
+    @readonly
+    def issuperset(self, other: set[T]) -> bool: ...
+
+    @native("tpy::set_isdisjoint", function=True)
+    @pure
+    @readonly
+    def isdisjoint(self, other: set[T]) -> bool: ...
+
+    # In-place set algebra
+    @native("tpy::set_update", function=True)
+    def update(self, other: set[T]) -> None: ...
+
+    @native("tpy::set_intersection_update", function=True)
+    def intersection_update(self, other: set[T]) -> None: ...
+
+    @native("tpy::set_difference_update", function=True)
+    def difference_update(self, other: set[T]) -> None: ...
+
+    @native("tpy::set_symmetric_difference_update", function=True)
+    def symmetric_difference_update(self, other: set[T]) -> None: ...
+
+    # Operators (same as named methods)
+    @native("tpy::set_union", function=True)
+    @pure
+    @readonly
+    def __or__(self, other: set[T]) -> Own[set[T]]: ...
+
+    @native("tpy::set_intersection", function=True)
+    @pure
+    @readonly
+    def __and__(self, other: set[T]) -> Own[set[T]]: ...
+
+    @native("tpy::set_difference", function=True)
+    @pure
+    @readonly
+    def __sub__(self, other: set[T]) -> Own[set[T]]: ...
+
+    @native("tpy::set_symmetric_difference", function=True)
+    @pure
+    @readonly
+    def __xor__(self, other: set[T]) -> Own[set[T]]: ...
+
+    # In-place operators
+    @native("tpy::set_update", function=True)
+    def __ior__(self, other: set[T]) -> set[T]: ...
+
+    @native("tpy::set_intersection_update", function=True)
+    def __iand__(self, other: set[T]) -> set[T]: ...
+
+    @native("tpy::set_difference_update", function=True)
+    def __isub__(self, other: set[T]) -> set[T]: ...
+
+    @native("tpy::set_symmetric_difference_update", function=True)
+    def __ixor__(self, other: set[T]) -> set[T]: ...

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

@@ -0,0 +1,11 @@
+# tpy: native_module
+# super() is a compile-time construct in TPy (no runtime super-proxy object);
+# this stub exists only to give `super` a qualified name so sema can resolve
+# call-site references through the normal namespace chain instead of matching
+# the bare string. A user `def super()` at module/function scope shadows this
+# binding the usual way, matching CPython semantics.
+from .._bootstrap._extern import builtin_type
+
+
+@builtin_type("builtins.super")
+class super: ...