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

tpyc/_data/runtime/cpp/include/tpy/stdlib/time.hpp

@@ -0,0 +1,62 @@
+#pragma once
+
+#include <chrono>
+#include <cstdint>
+#include <ctime>
+#include <thread>
+
+namespace tpy::stdlib::time {
+
+inline double perf_counter() {
+    auto now = std::chrono::steady_clock::now();
+    return std::chrono::duration<double>(now.time_since_epoch()).count();
+}
+
+inline int64_t perf_counter_ns() {
+    auto now = std::chrono::steady_clock::now();
+    return std::chrono::duration_cast<std::chrono::nanoseconds>(
+        now.time_since_epoch()).count();
+}
+
+// monotonic aliases perf_counter -- CPython ties them on POSIX, so a
+// distinct clock would only diverge artificially.
+
+inline double monotonic() {
+    return perf_counter();
+}
+
+inline int64_t monotonic_ns() {
+    return perf_counter_ns();
+}
+
+// system_clock can jump backward on NTP adjustments; callers measuring
+// elapsed time should use monotonic_ns instead.
+
+inline int64_t time_ns() {
+    auto now = std::chrono::system_clock::now();
+    return std::chrono::duration_cast<std::chrono::nanoseconds>(
+        now.time_since_epoch()).count();
+}
+
+// process_time: CPU time consumed by the current process, in seconds.
+// CPython uses clock_gettime(CLOCK_PROCESS_CPUTIME_ID) where available;
+// std::clock() is the portable C++ fallback (resolution typically ~1us
+// on Linux, lower on some platforms).
+
+inline double process_time() {
+    return static_cast<double>(std::clock()) / CLOCKS_PER_SEC;
+}
+
+// Sleep until a steady_clock deadline expressed as seconds since the
+// clock's epoch (the same domain as monotonic() / perf_counter()).
+// Returns immediately if the deadline is already in the past.
+// Used by asyncio's TPy-side run loop to wait for the next timer.
+inline void sleep_until_steady(double deadline_seconds) {
+    using DurDouble = std::chrono::duration<double>;
+    using TP = std::chrono::steady_clock::time_point;
+    auto deadline = TP(std::chrono::duration_cast<TP::duration>(
+        DurDouble(deadline_seconds)));
+    std::this_thread::sleep_until(deadline);
+}
+
+} // namespace tpy::stdlib::time

tpyc/_data/runtime/cpp/include/tpy/system.hpp

@@ -0,0 +1,121 @@
+/**
+ * TurboPython Runtime - System Utilities
+ *
+ * Time functions, sys.argv, and sys.stdout / sys.stderr wrappers.
+ */
+
+#pragma once
+
+#include <chrono>
+#include <cstddef>
+#include <cstdint>
+#include <iostream>
+#include <ostream>
+#include <string>
+#include <string_view>
+#include <thread>
+#include <vector>
+
+#include "core.hpp"
+
+namespace tpy {
+
+/**
+ * time_time - Return seconds since epoch as double.
+ *
+ * Equivalent to Python's time.time().
+ */
+inline double time_time() {
+    auto now = std::chrono::system_clock::now();
+    auto duration = now.time_since_epoch();
+    return std::chrono::duration<double>(duration).count();
+}
+
+/**
+ * time_sleep - Suspend execution for the given number of seconds.
+ *
+ * Equivalent to Python's time.sleep().
+ */
+inline void time_sleep(double seconds) {
+    if (seconds < 0) {
+        raise_value_error("sleep length must be non-negative");
+    }
+    auto duration = std::chrono::duration<double>(seconds);
+    std::this_thread::sleep_for(duration);
+}
+
+/**
+ * sys_argv - Command line arguments as vector of string_view.
+ *
+ * Equivalent to Python's sys.argv. Initialized by init_sys_argv() in main().
+ * Note: string_views point to argv strings which are valid for program lifetime.
+ */
+inline std::vector<std::string_view> sys_argv;
+
+/**
+ * get_sys_argv - Return sys_argv as owned strings for module-level init.
+ *
+ * Called once during sys module init, after init_sys_argv() has populated sys_argv.
+ */
+inline std::vector<std::string> get_sys_argv() {
+    return {sys_argv.begin(), sys_argv.end()};
+}
+
+/**
+ * sys_exit - Terminate the program with the given exit code.
+ *
+ * Equivalent to Python's sys.exit(code) for an integer argument.
+ * Static destructors and atexit handlers run; thread-local
+ * destructors and finally clauses do NOT (this is std::exit, not
+ * a thrown SystemExit). Acceptable for a v1 binding driven by
+ * argparse's --help / parse-error paths.
+ */
+[[noreturn]] inline void sys_exit(int code) {
+    std::exit(code);
+}
+
+/**
+ * init_sys_argv - Initialize sys_argv from main()'s argc/argv.
+ *
+ * Called at program startup before __tpy_init().
+ */
+inline void init_sys_argv(int argc, char* argv[]) {
+    sys_argv.clear();
+    sys_argv.reserve(static_cast<std::size_t>(argc));
+    for (int i = 0; i < argc; ++i) {
+        sys_argv.emplace_back(argv[i]);
+    }
+}
+
+/**
+ * StdStream - non-owning wrapper around std::cout / std::cerr.
+ *
+ * Backs sys.stdout / sys.stderr; satisfies the Writable protocol so it works
+ * as a `print(file=...)` target alongside TextFile and user types.
+ */
+class StdStream {
+    std::ostream* sink_;
+
+public:
+    explicit StdStream(std::ostream& s) : sink_(&s) {}
+
+    int32_t write(std::string_view text) {
+        sink_->write(text.data(), static_cast<std::streamsize>(text.size()));
+        return static_cast<int32_t>(text.size());
+    }
+
+    void flush() { sink_->flush(); }
+
+    std::ostream& sink() const { return *sink_; }
+
+    friend std::ostream& operator<<(std::ostream& os, const StdStream& s) {
+        if (s.sink_ == &std::cout) return os << "<sys.stdout>";
+        if (s.sink_ == &std::cerr) return os << "<sys.stderr>";
+        return os << "<StdStream>";
+    }
+};
+
+inline StdStream get_sys_stdout() { return StdStream(std::cout); }
+inline StdStream get_sys_stderr() { return StdStream(std::cerr); }
+
+} // namespace tpy

tpyc/_data/runtime/cpp/include/tpy/throwable.hpp

@@ -0,0 +1,55 @@
+/**
+ * TurboPython Runtime - Throwable ABI
+ *
+ * Abstract base for the TPy exception hierarchy. Phase 20 (E9) promotes
+ * `Throwable` from a markerless `@dynamic` protocol to a real one with
+ * two virtuals so user code can store polymorphic exceptions in
+ * `Box[Throwable]` and rethrow them without slicing.
+ *
+ *   - clone()    -- polymorphic copy on the heap (used by Box(e.clone())).
+ *   - __raise__() -- throws *this as the dynamic type, preserving the
+ *                    concrete subclass through C++ unwinding.
+ *
+ * what() stays as the std::exception virtual; the BaseException
+ * implementation returns the inherited `message` field.
+ *
+ * Stage 2a (this file) ships the abstract base and a per-class macro
+ * that emits the two overrides for every native exception subclass in
+ * core.hpp / async.hpp. Stage 4 deletes this macro when codegen auto-
+ * emits the same overrides on every TPy-defined Throwable subclass.
+ */
+
+#pragma once
+
+#include <exception>
+#include <memory>
+
+#include "type_traits.hpp"
+
+namespace tpy {
+
+struct Throwable : std::exception {
+    [[nodiscard]] virtual std::unique_ptr<Throwable> clone() const = 0;
+    [[noreturn]] virtual void __raise__() const = 0;
+    ~Throwable() override = default;
+};
+
+}  // namespace tpy
+
+// Marks ::tpy::Throwable as a @dynamic-protocol base for the polymorphism
+// predicate `is_polymorphic_class_type`. Normally codegen emits this
+// specialization alongside its codegen-emitted abstract base; for
+// `@native + @dynamic` protocols the codegen path is suppressed and the
+// runtime supplies it.
+template<> struct tpy::is_dyn_protocol_base<::tpy::Throwable> : std::true_type {};
+
+// Per-class boilerplate for native exception subclasses. Stage 4 of Phase 20
+// retires this macro in favor of codegen auto-emission on every TPy-defined
+// Throwable subclass; until then, every concrete native subclass needs both
+// overrides explicitly (inheriting them from BaseException would slice the
+// dynamic type at clone() / __raise__() sites).
+#define TPY_THROWABLE_VIRTUALS(ThisClass) \
+    [[nodiscard]] std::unique_ptr<::tpy::Throwable> clone() const override { \
+        return std::make_unique<ThisClass>(*this); \
+    } \
+    [[noreturn]] void __raise__() const override { throw *this; }

tpyc/_data/runtime/cpp/include/tpy/tpy.hpp

@@ -0,0 +1,156 @@
+/**
+ * TurboPython Runtime - Main Header
+ *
+ * Includes all runtime components. This is the primary header for
+ * TurboPython generated code.
+ *
+ * Requires C++23 for std::ranges concepts.
+ */
+
+#pragma once
+
+// Core utilities (no dependencies)
+#include "core.hpp"
+
+// Async primitives: CancelledError only. Waker / Awaker / Poll<T> /
+// Awaitable<T> are pure-TPy in `lib/tpy/tpy/coro/__init__.py` (Waker,
+// Awaker, Awaitable concept) and `lib/tpy/tpy/_core/_types.py` (Poll).
+#include "async.hpp"
+
+// Enum utility trait (primary template; specializations in generated code)
+#include "enum.hpp"
+
+// Dynamic protocol adapters (primary templates; specializations in generated code)
+#include "dynamic.hpp"
+
+// Formatting (no dependencies)
+#include "format.hpp"
+
+// Fixed-width integer checked arithmetic (depends on core)
+#include "fixed_int.hpp"
+
+// Type traits (no dependencies)
+#include "type_traits.hpp"
+
+// Range utilities (no dependencies)
+#include "ranges.hpp"
+
+// Range iterator (depends on core, fixed_int)
+#include "range.hpp"
+
+// Uninitialized storage (depends on core)
+#include "uninit_array_storage.hpp"
+#include "uninit_heap_storage.hpp"
+#include "frame_slot.hpp"
+
+// BigInt arbitrary precision (depends on core, fixed_int, type_traits)
+#include "bigint.hpp"
+
+// Builtin function helpers (depends on core, fixed_int, bigint)
+#include "builtins.hpp"
+
+// Slice type for user-defined __getitem__ overloads (no dependencies)
+#include "slice.hpp"
+
+// Container operations (depends on core, type_traits)
+#include "container_ops.hpp"
+
+// Protocols and concepts (depends on ranges)
+#include "protocols.hpp"
+
+// next_iter adapter: begin()/end() for __next__()-based iterators
+#include "next_iter.hpp"
+
+// Generator expression wrapper (depends on next_iter, <optional>, <expected>)
+#include "generator.hpp"
+
+// SpanIter: lightweight iterator over contiguous span (depends on <span>, error_return)
+#include "span_iter.hpp"
+
+// varargs<T>: dual-mode span for *args (direct contiguous or indirect pointer array)
+#include "varargs.hpp"
+
+// OwnIter: drain iterator for std::vector (depends on core)
+#include "own_iter.hpp"
+
+// CopyIter: copying iterator adapter (depends on dunder for __iter__)
+#include "copy_iter.hpp"
+
+// Iterator builtins: enumerate, reversed (depends on next_iter, dunder)
+#include "itertools.hpp"
+
+// Non-range overloads for container ops (depends on dunder, container_ops)
+#include "iterable_ops.hpp"
+
+// Collection printing (depends on bigint)
+#include "printing.hpp"
+
+// Ordered map (no runtime dependencies beyond standard library)
+#include "ordered_map.hpp"
+
+// Ordered set (no runtime dependencies beyond standard library)
+#include "ordered_set.hpp"
+
+// Dict operations and printing (depends on ordered_map, core, printing)
+#include "dict_ops.hpp"
+
+// Set operations and printing (depends on ordered_set, core, printing)
+#include "set_ops.hpp"
+
+// Bytes operations and printing (depends on core, container_ops)
+#include "bytes_ops.hpp"
+
+// System utilities (depends on core)
+#include "system.hpp"
+
+// Pointer-variant utilities for non-value union types (depends on <variant>)
+#include "variant_ref.hpp"
+
+// File I/O: TextFile for open() builtin (depends on core)
+#include "file.hpp"
+
+// User-facing TPy type names (depends on core, plus every type it
+// specializes for -- so it must come after the type headers above)
+#include "type_name.hpp"
+
+// Any: type-erased value cell (depends on dunder, builtins, core, type_name)
+#include "any.hpp"
+
+// Output-sink dispatch for print(file=...) (depends on system, file)
+#include "as_ostream.hpp"
+
+// repr_of: user-facing repr dispatch helper. Defined here, after every
+// header that contributes a tpy::__repr__ overload, so unqualified
+// `__repr__(x)` inside its body sees the full overload set. Goes through
+// here (not direct `::tpy::__repr__`) so ADL into the argument's
+// namespace can find per-record overrides; qualified callers from inside
+// runtime templates would freeze the candidate set at template-definition
+// time and miss them.
+namespace tpy {
+template<typename T>
+inline auto repr_of(const T& x) {
+    using ::tpy::__repr__;
+    return __repr__(x);
+}
+
+// Pointer-repr Optional[Record] (`A | None` lowers to nullable `A*`):
+// emit "None" for null, otherwise repr the pointee. Restricted to class
+// pointers so raw `int*`/`char*` don't get caught (the latter has its
+// own __repr__ for string literals).
+template<typename T>
+    requires std::is_class_v<T>
+inline std::string repr_of(T* p) {
+    if (!p) return "None";
+    using ::tpy::__repr__;
+    return std::string(__repr__(*p));
+}
+} // namespace tpy
+
+// Expose types in global namespace for TurboPython generated code
+using ::tpy::UninitArrayStorage;
+using ::tpy::UninitHeapStorage;
+using ::tpy::tpy_panic;
+using ::tpy::BigInt;
+using ::tpy::BaseException;
+using ::tpy::Exception;
+using ::tpy::StopIteration;

tpyc/_data/runtime/cpp/include/tpy/type_name.hpp

@@ -0,0 +1,77 @@
+/**
+ * TurboPython Runtime - User-facing type names
+ *
+ * tpy::type_name<T>() returns the TPy-level name of a C++ type
+ * ("int" for tpy::BigInt, "str" for std::string, "Int32" for int32_t,
+ * "module.Cls" for user records via their `__tpy_class_name__` member,
+ * etc.). Used for diagnostics that surface to TPy users (Any cast errors,
+ * etc.) so messages don't leak C++ implementation details.
+ *
+ * Falls back to the demangled typeid for types without a specialization;
+ * the demangler output is normalized to be stable across libc++/libstdc++.
+ *
+ * Depends on: core.hpp (demangle_type_name), all type headers it
+ * specializes for. Include via tpy.hpp after the type headers.
+ */
+
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+#include <string>
+#include <typeinfo>
+#include <variant>
+
+#include "core.hpp"
+
+namespace tpy {
+
+class BigInt;
+
+// Primary template: derives a name for any T not covered by an explicit
+// specialization below. Splits on whether T carries the codegen-emitted
+// `__tpy_class_name__` member (user records / dataclasses) so we don't
+// have to enumerate generated types.
+template <typename T>
+struct type_name_for {
+    static std::string get() {
+        if constexpr (requires { T::__tpy_class_name__; }) {
+            return std::string(T::__tpy_class_name__);
+        } else {
+            return demangle_type_name(typeid(T).name());
+        }
+    }
+};
+
+template <typename T>
+inline std::string type_name() {
+    return type_name_for<T>::get();
+}
+
+// Built-in TPy <-> C++ type pairings. Keep in sync with the type table in
+// CLAUDE.md / docs/LANGUAGE_FEATURES.md.
+#define TPY_TYPE_NAME_(CPP_TYPE, TPY_NAME)                       \
+    template <> struct type_name_for<CPP_TYPE> {                 \
+        static std::string get() { return TPY_NAME; }            \
+    }
+
+TPY_TYPE_NAME_(BigInt,          "int");
+TPY_TYPE_NAME_(bool,            "bool");
+TPY_TYPE_NAME_(char,            "Char");
+TPY_TYPE_NAME_(int8_t,          "Int8");
+TPY_TYPE_NAME_(int16_t,         "Int16");
+TPY_TYPE_NAME_(int32_t,         "Int32");
+TPY_TYPE_NAME_(int64_t,         "Int64");
+TPY_TYPE_NAME_(uint8_t,         "UInt8");
+TPY_TYPE_NAME_(uint16_t,        "UInt16");
+TPY_TYPE_NAME_(uint32_t,        "UInt32");
+TPY_TYPE_NAME_(uint64_t,        "UInt64");
+TPY_TYPE_NAME_(float,           "Float32");
+TPY_TYPE_NAME_(double,          "Float64");
+TPY_TYPE_NAME_(std::string,     "str");
+TPY_TYPE_NAME_(std::nullptr_t,  "None");
+TPY_TYPE_NAME_(std::monostate,  "None");
+
+#undef TPY_TYPE_NAME_
+
+}  // namespace tpy