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

tpyc/_data/lib/tpy/tpy/__init__.py

@@ -0,0 +1,78 @@
+# tpy: native_module
+# tpy: cpp_namespace("tpystd::tpy")
+# _bootstrap must be imported before _core: _bootstrap._extern defines
+# @builtin_decorator stubs whose arg schemas are needed when parsing
+# decorator kwargs (e.g. @native(function=True)) in _core/_types.py.
+from ._bootstrap import (
+    # Decorators / type modifiers
+    readonly, noalloc, nocopy, pure, inline, dynamic, error_return,
+    Own, Fn,
+)
+from ._core import (
+    # Structural protocols
+    Truthy, Stringable, Representable, Hashable, Comparable, Equatable,
+    Deref, Spannable, Writable, Readable, BinaryWritable, BinaryReadable,
+    Seekable, Closable,
+    # Marker protocols
+    NativeIterable, NativeRangeConstructible, ValueType, Copyable, Send, Sync,
+    Default, Covariant, ReturnException,
+    # Fixed-width integer constraint protocols
+    AnyFixedInt, AnyFixedSigned, AnyFixedUnsigned,
+    # Primitive types
+    Float32,
+    Int8, Int16, Int32, Int64,
+    UInt8, UInt16, UInt32, UInt64,
+    Char, String, StrView, FStr, BytesView,
+    # Container types
+    Span, Array, Ptr, SpanIter,
+    # Functions
+    span, deref, take_ptr, make_default,
+    copy, copy_iter, own_iter, try_parse,
+)
+# `Task` / `Waker` / `Poll` / `Awaitable` / `poll_*` are not re-exported
+# here -- importing from `tpy` would force every consumer to include
+# `tpystd/coro.hpp` transitively. Use `from tpy.coro import ...`.
+from ._builtins._exceptions import CancelledError
+from ._builtins._types import basic_slice
+from ._builtins._io import BinaryIO, open_text, open_binary
+
+type Float64 = float
+
+# Version/implementation identification lives in `tpy.version` submodule:
+#     from tpy.version import __version__, version_info, is_compiled
+# Not re-exported here because native_module facades don't propagate
+# variable imports or transitive init chains.
+
+__all__ = [
+    # Primitive types
+    "Int8", "Int16", "Int32", "Int64",
+    "UInt8", "UInt16", "UInt32", "UInt64",
+    "Float32", "Float64",
+    "Char", "String", "StrView", "FStr", "BytesView",
+    # Container types
+    "Span", "Array", "Ptr", "SpanIter",
+    # Slice types
+    "basic_slice",
+    # Pointer / ownership
+    "Own", "Fn",
+    # Decorators / type modifiers
+    "readonly", "noalloc", "nocopy", "pure", "inline", "dynamic", "error_return",
+    "auto_readonly", "auto_own",  # parser keywords (no .py stub)
+    # Structural protocols
+    "Truthy", "Stringable", "Representable",
+    "Hashable", "Comparable", "Equatable",
+    "Deref", "Spannable", "Writable", "Readable",
+    "BinaryWritable", "BinaryReadable",
+    "Seekable", "Closable", "Default",
+    # Marker protocols
+    "NativeIterable", "NativeRangeConstructible",
+    "ValueType", "Copyable", "Send", "Sync", "Covariant", "ReturnException",
+    # Fixed-width integer constraint protocols
+    "AnyFixedInt", "AnyFixedSigned", "AnyFixedUnsigned",
+    # Functions
+    "span", "deref", "take_ptr", "make_default",
+    "copy", "copy_iter", "own_iter", "try_parse",
+    "CancelledError",
+    # I/O
+    "BinaryIO", "open_text", "open_binary",
+]

tpyc/_data/lib/tpy/tpy/_bootstrap/__init__.py

@@ -0,0 +1,10 @@
+# tpy: native_module
+from ._extern import (
+    builtin_decorator, builtin_type,
+    native, cpp_template,
+    value_ptr_coercion, native_preserves_refs,
+)
+from ._decorators import (
+    readonly, noalloc, nocopy, pure, inline, dynamic, error_return,
+    Own, Fn,
+)

tpyc/_data/lib/tpy/tpy/_bootstrap/_decorators.py

@@ -0,0 +1,37 @@
+# tpy: native_module
+# tpy: cpp_namespace("tpystd::tpy")
+# Decorator and type modifier stubs for import resolution.
+# Type modifier stubs use @builtin_type so the compiler knows their
+# qualified name (e.g. "tpy.Own"). Codegen skips them via is_keyword_stub.
+# Decorator stubs use @builtin_decorator so the compiler resolves them
+# by qualified name (e.g. "tpy.readonly"). Codegen skips via is_decorator_stub.
+# Stub signatures define argument schemas -- the parser derives validation
+# rules from params (type and default) instead of hardcoding them.
+from ._extern import builtin_type, builtin_decorator
+
+@builtin_type("tpy.Own")
+class Own: ...
+
+@builtin_type("tpy.Fn")
+class Fn: ...
+
+@builtin_decorator("tpy.readonly")
+def readonly(is_readonly: bool = True): ...
+
+@builtin_decorator("tpy.noalloc")
+def noalloc(): ...
+
+@builtin_decorator("tpy.nocopy")
+def nocopy(): ...
+
+@builtin_decorator("tpy.dynamic")
+def dynamic(): ...
+
+@builtin_decorator("tpy.pure")
+def pure(): ...
+
+@builtin_decorator("tpy.inline")
+def inline(): ...
+
+@builtin_decorator("tpy.error_return")
+def error_return(exc_type: type): ...

tpyc/_data/lib/tpy/tpy/_bootstrap/_extern.py

@@ -0,0 +1,64 @@
+# tpy: native_module
+# tpy: cpp_namespace("tpystd::tpy")
+# Extern decorator stubs. builtin_decorator is the bootstrap primitive
+# (auto-resolved within this module via _EXTERN_KEYWORDS). All other
+# decorators are defined using @builtin_decorator.
+
+@builtin_decorator("tpy.extern.builtin_decorator")
+def builtin_decorator(key: str): ...
+
+@builtin_decorator("tpy.extern.builtin_type")
+def builtin_type(key: str): ...
+
+@builtin_decorator("tpy.extern.builtin_function")
+def builtin_function(key: str): ...
+
+@builtin_decorator("tpy.extern.native")
+def native(name: str = "", function: bool = False, binding: str = "",
+           cpp_return_type: type | None = None, indirecting: bool = False): ...
+
+@builtin_decorator("tpy.extern.export")
+def export(name: str = "", binding: str = ""): ...
+
+# Prefer @native over @cpp_template -- use only when @native can't express the
+# call (e.g. wrapping in a constructor, type cast, or non-trivial expression).
+@builtin_decorator("tpy.extern.cpp_template")
+def cpp_template(template: str): ...
+
+@builtin_decorator("tpy.extern.value_ptr_coercion")
+def value_ptr_coercion(): ...
+
+@builtin_decorator("tpy.extern.native_preserves_refs")
+def native_preserves_refs(): ...
+
+# Workaround for Python 3.12 -- Python 3.13+ has native type param defaults
+# (PEP 696): def round[T = int](x: float) -> T: ...
+@builtin_decorator("tpy.extern.type_param_default")
+def type_param_default(): ...
+
+# Sentinel for @type_param_default: resolves to the configured --default-int type.
+# TODO: make this a real type alias (e.g. `type DefaultInt = ...`) with compiler
+# support, so it can be used in type annotations beyond @type_param_default.
+@builtin_type("tpy.extern.DefaultInt")
+class DefaultInt: pass
+
+
+# Native global variable declarations for C/C++ interop.
+# TODO: design a macro function mechanism so these set variable properties
+# (linkage, extern name) through the macro system instead of special handling.
+@builtin_function("tpy.extern.native_global")
+def native_global(name: str = "", binding: str = "", array: bool = False): ...
+
+# Per-field C++ rename on @native classes. Used in the default-value slot of
+# an annotated field on an @native class; the compiler extracts the rename
+# string and drops the expression (no initializer is emitted for native fields).
+@builtin_function("tpy.extern.native_field")
+def native_field(name: str): ...
+
+# Per-member C++ rename on @native enums. Used in the value slot of an enum
+# member; the compiler extracts the rename string and treats the value as
+# unspecified (the C++ side is the source of truth for the actual value).
+# Useful when the C++ enumerator name clashes with a Python keyword
+# (`None`, `True`, `False`) or follows a different naming convention.
+@builtin_function("tpy.extern.native_member")
+def native_member(name: str): ...

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

@@ -0,0 +1,11 @@
+# tpy: native_module
+from ._exceptions import BaseException, Exception, ValueError, OSError, FileNotFoundError, AttributeError, AssertionError, IndexError, KeyError, ArithmeticError, ZeroDivisionError, OverflowError, TypeError, NotImplementedError, RuntimeError, MemoryError, StopIteration, StopAsyncIteration, TimeoutError, CancelledError
+from ._range import Range, range
+from ._funcs import len, repr, hash, chr, ord, abs, min, max, pow, divmod, next, iter, round, print, input, isinstance, all, any, sum, sorted, bin, hex, oct, enumerate, reversed, zip, map, filter, getattr, setattr, delattr, hasattr
+from ._bytes import bytes, bytearray
+from ._types import bool, int, float, str, slice
+from ._list import list
+from ._dict import dict, dict_keys, dict_values, dict_items
+from ._set import set
+from ._io import TextIO, BinaryIO, open, open_text, open_binary
+from ._super import super

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

@@ -0,0 +1,378 @@
+# 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 UInt8, UInt64, Int32, Equatable, NativeIterable
+from .._bootstrap._extern import native, cpp_template, builtin_type
+from tpy import BytesView
+
+
+@builtin_type("builtins.bytes")
+@native("std::vector<uint8_t>")
+class bytes(NativeIterable[UInt8], Iterable[UInt8], Equatable):
+    @overload
+    @cpp_template("std::vector<uint8_t>()")
+    def __init__(self) -> None: ...
+    @overload
+    @native("tpy::bytes_copy", function=True)
+    def __init__(self, x: bytes) -> None: ...
+    @overload
+    @native("tpy::bytes_copy", function=True)
+    def __init__(self, x: bytearray) -> None: ...
+    @overload
+    @native("tpy::bytes_copy", function=True)
+    def __init__(self, x: BytesView) -> None: ...
+    @overload
+    @native("tpy::bytes_from_size", function=True)
+    def __init__(self, x: Int32) -> None: ...
+    @overload
+    @cpp_template("::tpy::construct<std::vector<uint8_t>>({0})")
+    def __init__(self, x: Iterable[UInt8]) -> None: ...
+    # TODO(hot-path): the Int32 overload below is per-element range-checked.
+    @overload
+    @native("tpy::bytes_from_int_iterable", function=True)
+    def __init__(self, x: Iterable[Int32]) -> None: ...
+
+    @native("tpy::__iter__", function=True)
+    @readonly
+    @pure
+    def __iter__(self) -> Iterator[UInt8]: ...
+
+    @native("tpy::__len__", function=True)
+    @readonly
+    @pure
+    def __len__(self) -> Int32: ...
+
+    @overload
+    @native("tpy::bytes_getitem", function=True)
+    @readonly
+    @pure
+    def __getitem__(self, index: Int32) -> UInt8: ...
+
+    @overload
+    @cpp_template("::tpy::bytes_slice({self}, {0})")
+    @readonly
+    @pure
+    def __getitem__(self, index: basic_slice) -> BytesView: ...
+
+    @overload
+    @cpp_template("::tpy::bytes_stepped_slice({self}, {0})")
+    @readonly
+    @pure
+    def __getitem__(self, index: slice) -> bytes: ...
+
+    @overload
+    @native("tpy::bytes_contains", function=True)
+    @readonly
+    @pure
+    def __contains__(self, value: UInt8) -> bool: ...
+    @overload
+    @native("tpy::bytes_contains_sub", function=True)
+    @readonly
+    @pure
+    def __contains__(self, value: bytes) -> bool: ...
+
+    @overload
+    @native("tpy::bytes_concat", function=True)
+    @readonly
+    def __add__(self, other: bytes) -> bytes: ...
+    @overload
+    @native("tpy::bytes_concat", function=True)
+    @readonly
+    def __add__(self, other: bytearray) -> bytes: ...
+    @overload
+    @native("tpy::bytes_concat", function=True)
+    @readonly
+    def __add__(self, other: BytesView) -> bytes: ...
+
+    @native("tpy::bytes_repeat", function=True)
+    @readonly
+    @pure
+    def __mul__(self, n: Int32) -> bytes: ...
+
+    @native("tpy::bytes_repeat", function=True)
+    @readonly
+    @pure
+    def __rmul__(self, n: Int32) -> bytes: ...
+
+    @native("tpy::bytes_eq", function=True)
+    @readonly
+    @pure
+    def __eq__(self, other: bytes) -> bool: ...
+
+    @cpp_template("::tpy::__hash__({self})")
+    @readonly
+    @pure
+    def __hash__(self) -> UInt64: ...
+
+    @native("tpy::bytes_decode", function=True)
+    @readonly
+    @pure
+    def decode(self) -> str: ...
+
+    @native("tpy::bytes_hex", function=True)
+    @readonly
+    @pure
+    def hex(self) -> str: ...
+
+    @native("tpy::bytes_find", function=True)
+    @readonly
+    @pure
+    def find(self, sub: bytes) -> Int32: ...
+
+    @native("tpy::bytes_rfind", function=True)
+    @readonly
+    @pure
+    def rfind(self, sub: bytes) -> Int32: ...
+
+    @native("tpy::bytes_count", function=True)
+    @readonly
+    @pure
+    def count(self, sub: bytes) -> Int32: ...
+
+    @native("tpy::bytes_startswith", function=True)
+    @readonly
+    @pure
+    def startswith(self, prefix: bytes) -> bool: ...
+
+    @native("tpy::bytes_endswith", function=True)
+    @readonly
+    @pure
+    def endswith(self, suffix: bytes) -> bool: ...
+
+    @native("tpy::bytes_replace", function=True)
+    @readonly
+    @pure
+    def replace(self, old: bytes, new: bytes) -> bytes: ...
+
+    @native("tpy::bytes_split", function=True)
+    @readonly
+    @pure
+    def split(self, sep: bytes) -> Own[list[bytes]]: ...
+
+    @native("tpy::bytes_join", function=True)
+    @readonly
+    @pure
+    def join(self, items: Iterable[bytes]) -> bytes: ...
+
+    @native("tpy::bytes_strip", function=True)
+    @readonly
+    @pure
+    def strip(self) -> bytes: ...
+
+    @native("tpy::bytes_lstrip", function=True)
+    @readonly
+    @pure
+    def lstrip(self) -> bytes: ...
+
+    @overload
+    @native("tpy::bytes_rstrip", function=True)
+    @readonly
+    @pure
+    def rstrip(self) -> bytes: ...
+    @overload
+    @native("tpy::bytes_rstrip_chars", function=True)
+    @readonly
+    @pure
+    def rstrip(self, chars: bytes) -> bytes: ...
+
+    @native("tpy::bytes_upper", function=True)
+    @readonly
+    @pure
+    def upper(self) -> bytes: ...
+
+
+@builtin_type("builtins.bytearray")
+@native("std::vector<uint8_t>")
+class bytearray(NativeIterable[UInt8], Iterable[UInt8], Equatable):
+    @overload
+    @cpp_template("std::vector<uint8_t>()")
+    def __init__(self) -> None: ...
+    # Concrete overloads first, same rationale as in `bytes` above.
+    @overload
+    @native("tpy::bytes_copy", function=True)
+    def __init__(self, x: bytes) -> None: ...
+    @overload
+    @native("tpy::bytes_copy", function=True)
+    def __init__(self, x: BytesView) -> None: ...
+    @overload
+    @native("tpy::bytes_copy", function=True)
+    def __init__(self, x: bytearray) -> None: ...
+    @overload
+    @native("tpy::bytes_from_size", function=True)
+    def __init__(self, x: Int32) -> None: ...
+    @overload
+    @cpp_template("::tpy::construct<std::vector<uint8_t>>({0})")
+    def __init__(self, x: Iterable[UInt8]) -> None: ...
+    # TODO(hot-path): the Int32 overload below is per-element range-checked.
+    @overload
+    @native("tpy::bytes_from_int_iterable", function=True)
+    def __init__(self, x: Iterable[Int32]) -> None: ...
+
+    @native("tpy::__iter__", function=True)
+    @readonly
+    @pure
+    def __iter__(self) -> Iterator[UInt8]: ...
+
+    @native("tpy::__len__", function=True)
+    @readonly
+    @pure
+    def __len__(self) -> Int32: ...
+
+    @overload
+    @native("tpy::bytes_getitem", function=True)
+    @readonly
+    @pure
+    def __getitem__(self, index: Int32) -> UInt8: ...
+
+    @overload
+    @cpp_template("::tpy::bytes_slice({self}, {0})")
+    @readonly
+    @pure
+    def __getitem__(self, index: basic_slice) -> BytesView: ...
+
+    @overload
+    @cpp_template("::tpy::bytes_stepped_slice({self}, {0})")
+    @readonly
+    @pure
+    def __getitem__(self, index: slice) -> bytes: ...
+
+    @overload
+    @native("tpy::bytes_contains", function=True)
+    @readonly
+    @pure
+    def __contains__(self, value: UInt8) -> bool: ...
+    @overload
+    @native("tpy::bytes_contains_sub", function=True)
+    @readonly
+    @pure
+    def __contains__(self, value: bytes) -> bool: ...
+
+    @native("tpy::bytearray_setitem", function=True)
+    def __setitem__(self, index: Int32, value: UInt8) -> None: ...
+
+    @overload
+    @native("tpy::bytes_concat", function=True)
+    @readonly
+    def __add__(self, other: bytes) -> bytearray: ...
+    @overload
+    @native("tpy::bytes_concat", function=True)
+    @readonly
+    def __add__(self, other: bytearray) -> bytearray: ...
+    @overload
+    @native("tpy::bytes_concat", function=True)
+    @readonly
+    def __add__(self, other: BytesView) -> bytearray: ...
+
+    @native("tpy::bytes_repeat", function=True)
+    @readonly
+    @pure
+    def __mul__(self, n: Int32) -> bytearray: ...
+
+    @native("tpy::bytes_eq", function=True)
+    @readonly
+    @pure
+    def __eq__(self, other: bytearray) -> bool: ...
+
+    @native("push_back")
+    def append(self, value: UInt8) -> None: ...
+
+    @overload
+    @native("tpy::extend", function=True)
+    def extend(self, other: Iterable[UInt8]) -> None: ...
+    # TODO(hot-path): the Int32 overload below is per-element range-checked.
+    @overload
+    @native("tpy::bytes_extend_int_iterable", function=True)
+    def extend(self, other: Iterable[Int32]) -> None: ...
+
+    @overload
+    @native("tpy::bytearray_pop", function=True)
+    def pop(self) -> UInt8: ...
+    @overload
+    @native("tpy::bytearray_pop_at", function=True)
+    def pop(self, index: Int32) -> UInt8: ...
+
+    @native
+    def clear(self) -> None: ...
+
+    @native("tpy::bytearray_insert", function=True)
+    def insert(self, index: Int32, value: UInt8) -> None: ...
+
+    @native("tpy::bytearray_remove", function=True)
+    def remove(self, value: UInt8) -> None: ...
+
+    @native("tpy::bytes_decode", function=True)
+    @readonly
+    @pure
+    def decode(self) -> str: ...
+
+    @native("tpy::bytes_hex", function=True)
+    @readonly
+    @pure
+    def hex(self) -> str: ...
+
+    @native("tpy::bytes_find", function=True)
+    @readonly
+    @pure
+    def find(self, sub: bytes) -> Int32: ...
+
+    @native("tpy::bytes_rfind", function=True)
+    @readonly
+    @pure
+    def rfind(self, sub: bytes) -> Int32: ...
+
+    @native("tpy::bytes_count", function=True)
+    @readonly
+    @pure
+    def count(self, sub: bytes) -> Int32: ...
+
+    @native("tpy::bytes_startswith", function=True)
+    @readonly
+    @pure
+    def startswith(self, prefix: bytes) -> bool: ...
+
+    @native("tpy::bytes_endswith", function=True)
+    @readonly
+    @pure
+    def endswith(self, suffix: bytes) -> bool: ...
+
+    @native("tpy::bytes_replace", function=True)
+    @readonly
+    @pure
+    def replace(self, old: bytes, new: bytes) -> bytes: ...
+
+    @native("tpy::bytes_split", function=True)
+    @readonly
+    @pure
+    def split(self, sep: bytes) -> Own[list[bytes]]: ...
+
+    @native("tpy::bytes_join", function=True)
+    @readonly
+    @pure
+    def join(self, items: Iterable[bytes]) -> bytes: ...
+
+    @native("tpy::bytes_strip", function=True)
+    @readonly
+    @pure
+    def strip(self) -> bytearray: ...
+
+    @native("tpy::bytes_lstrip", function=True)
+    @readonly
+    @pure
+    def lstrip(self) -> bytearray: ...
+
+    @overload
+    @native("tpy::bytes_rstrip", function=True)
+    @readonly
+    @pure
+    def rstrip(self) -> bytearray: ...
+    @overload
+    @native("tpy::bytes_rstrip_chars", function=True)
+    @readonly
+    @pure
+    def rstrip(self, chars: bytes) -> bytearray: ...
+
+    @native("tpy::bytes_upper", function=True)
+    @readonly
+    @pure
+    def upper(self) -> bytearray: ...