feat: indie status page MVP -- FastAPI + SQLite

- 8 DB models (services, incidents, monitors, subscribers, etc.)
- Full CRUD API for services, incidents, monitors
- Public status page with live data
- Incident detail page with timeline
- API key authentication
- Uptime monitoring scheduler
- 13 tests passing
- TECHNICAL_DESIGN.md with full spec

venv/lib/python3.11/site-packages/mypyc/test/test_emit.py

@@ -0,0 +1,164 @@
+from __future__ import annotations
+
+import unittest
+
+from mypyc.codegen.emit import Emitter, EmitterContext
+from mypyc.common import HAVE_IMMORTAL
+from mypyc.ir.class_ir import ClassIR
+from mypyc.ir.ops import BasicBlock, Register, Value
+from mypyc.ir.rtypes import (
+    RInstance,
+    RTuple,
+    RUnion,
+    bool_rprimitive,
+    int_rprimitive,
+    list_rprimitive,
+    none_rprimitive,
+    object_rprimitive,
+    str_rprimitive,
+)
+from mypyc.irbuild.vtable import compute_vtable
+from mypyc.namegen import NameGenerator
+
+
+class TestEmitter(unittest.TestCase):
+    def setUp(self) -> None:
+        self.n = Register(int_rprimitive, "n")
+        self.context = EmitterContext(NameGenerator([["mod"]]), True)
+        self.emitter = Emitter(self.context, {})
+
+        ir = ClassIR("A", "mod")
+        compute_vtable(ir)
+        ir.mro = [ir]
+        self.instance_a = RInstance(ir)
+
+    def test_label(self) -> None:
+        assert self.emitter.label(BasicBlock(4)) == "CPyL4"
+
+    def test_reg(self) -> None:
+        names: dict[Value, str] = {self.n: "n"}
+        emitter = Emitter(self.context, names)
+        assert emitter.reg(self.n) == "cpy_r_n"
+
+    def test_object_annotation(self) -> None:
+        assert self.emitter.object_annotation("hello, world", "line;") == " /* 'hello, world' */"
+        assert self.emitter.object_annotation(list(range(30)), "line;") == """\
+ /* [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22,
+         23, 24, 25, 26, 27, 28, 29] */"""
+
+    def test_emit_line(self) -> None:
+        emitter = self.emitter
+        emitter.emit_line("line;")
+        emitter.emit_line("a {")
+        emitter.emit_line("f();")
+        emitter.emit_line("}")
+        assert emitter.fragments == ["line;\n", "a {\n", "    f();\n", "}\n"]
+        emitter = Emitter(self.context, {})
+        emitter.emit_line("CPyStatics[0];", ann="hello, world")
+        emitter.emit_line("CPyStatics[1];", ann=list(range(30)))
+        assert emitter.fragments[0] == "CPyStatics[0]; /* 'hello, world' */\n"
+        assert emitter.fragments[1] == """\
+CPyStatics[1]; /* [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
+                  21, 22, 23, 24, 25, 26, 27, 28, 29] */\n"""
+
+    def test_emit_undefined_value_for_simple_type(self) -> None:
+        emitter = self.emitter
+        assert emitter.c_undefined_value(int_rprimitive) == "CPY_INT_TAG"
+        assert emitter.c_undefined_value(str_rprimitive) == "NULL"
+        assert emitter.c_undefined_value(bool_rprimitive) == "2"
+
+    def test_emit_undefined_value_for_tuple(self) -> None:
+        emitter = self.emitter
+        assert (
+            emitter.c_undefined_value(RTuple([str_rprimitive, int_rprimitive, bool_rprimitive]))
+            == "(tuple_T3OIC) { NULL, CPY_INT_TAG, 2 }"
+        )
+        assert emitter.c_undefined_value(RTuple([str_rprimitive])) == "(tuple_T1O) { NULL }"
+        assert (
+            emitter.c_undefined_value(RTuple([RTuple([str_rprimitive]), bool_rprimitive]))
+            == "(tuple_T2T1OC) { { NULL }, 2 }"
+        )
+
+    def test_emit_inc_ref_object(self) -> None:
+        self.emitter.emit_inc_ref("x", object_rprimitive)
+        self.assert_output("CPy_INCREF(x);\n")
+
+    def test_emit_inc_ref_int(self) -> None:
+        self.emitter.emit_inc_ref("x", int_rprimitive)
+        self.assert_output("CPyTagged_INCREF(x);\n")
+
+    def test_emit_inc_ref_rare(self) -> None:
+        self.emitter.emit_inc_ref("x", object_rprimitive, rare=True)
+        self.assert_output("CPy_INCREF(x);\n")
+        self.emitter.emit_inc_ref("x", int_rprimitive, rare=True)
+        self.assert_output("CPyTagged_IncRef(x);\n")
+
+    def test_emit_inc_ref_list(self) -> None:
+        self.emitter.emit_inc_ref("x", list_rprimitive)
+        if HAVE_IMMORTAL:
+            self.assert_output("CPy_INCREF_NO_IMM(x);\n")
+        else:
+            self.assert_output("CPy_INCREF(x);\n")
+
+    def test_emit_inc_ref_instance(self) -> None:
+        self.emitter.emit_inc_ref("x", self.instance_a)
+        if HAVE_IMMORTAL:
+            self.assert_output("CPy_INCREF_NO_IMM(x);\n")
+        else:
+            self.assert_output("CPy_INCREF(x);\n")
+
+    def test_emit_inc_ref_optional(self) -> None:
+        optional = RUnion([self.instance_a, none_rprimitive])
+        self.emitter.emit_inc_ref("o", optional)
+        self.assert_output("CPy_INCREF(o);\n")
+
+    def test_emit_dec_ref_object(self) -> None:
+        self.emitter.emit_dec_ref("x", object_rprimitive)
+        self.assert_output("CPy_DECREF(x);\n")
+        self.emitter.emit_dec_ref("x", object_rprimitive, is_xdec=True)
+        self.assert_output("CPy_XDECREF(x);\n")
+
+    def test_emit_dec_ref_int(self) -> None:
+        self.emitter.emit_dec_ref("x", int_rprimitive)
+        self.assert_output("CPyTagged_DECREF(x);\n")
+        self.emitter.emit_dec_ref("x", int_rprimitive, is_xdec=True)
+        self.assert_output("CPyTagged_XDECREF(x);\n")
+
+    def test_emit_dec_ref_rare(self) -> None:
+        self.emitter.emit_dec_ref("x", object_rprimitive, rare=True)
+        self.assert_output("CPy_DecRef(x);\n")
+        self.emitter.emit_dec_ref("x", int_rprimitive, rare=True)
+        self.assert_output("CPyTagged_DecRef(x);\n")
+
+    def test_emit_dec_ref_list(self) -> None:
+        self.emitter.emit_dec_ref("x", list_rprimitive)
+        if HAVE_IMMORTAL:
+            self.assert_output("CPy_DECREF_NO_IMM(x);\n")
+        else:
+            self.assert_output("CPy_DECREF(x);\n")
+        self.emitter.emit_dec_ref("x", list_rprimitive, is_xdec=True)
+        if HAVE_IMMORTAL:
+            self.assert_output("CPy_XDECREF_NO_IMM(x);\n")
+        else:
+            self.assert_output("CPy_XDECREF(x);\n")
+
+    def test_emit_dec_ref_instance(self) -> None:
+        self.emitter.emit_dec_ref("x", self.instance_a)
+        if HAVE_IMMORTAL:
+            self.assert_output("CPy_DECREF_NO_IMM(x);\n")
+        else:
+            self.assert_output("CPy_DECREF(x);\n")
+        self.emitter.emit_dec_ref("x", self.instance_a, is_xdec=True)
+        if HAVE_IMMORTAL:
+            self.assert_output("CPy_XDECREF_NO_IMM(x);\n")
+        else:
+            self.assert_output("CPy_XDECREF(x);\n")
+
+    def test_emit_dec_ref_optional(self) -> None:
+        optional = RUnion([self.instance_a, none_rprimitive])
+        self.emitter.emit_dec_ref("o", optional)
+        self.assert_output("CPy_DECREF(o);\n")
+
+    def assert_output(self, expected: str) -> None:
+        assert "".join(self.emitter.fragments) == expected
+        self.emitter.fragments = []