cinderx 2026.1.16.2__cp314-cp314-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl

cinderx/test_support.py

@@ -0,0 +1,341 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# pyre-strict
+
+import abc
+import ctypes
+import dis
+import functools
+import importlib
+import multiprocessing
+import os.path
+import sys
+import tempfile
+import types
+import unittest
+from contextlib import contextmanager
+from pathlib import Path
+from typing import Callable, Coroutine, Generator, Sequence, TypeVar
+
+import cinderx
+import cinderx.jit
+
+try:
+    import cinder
+
+    def hasCinderX() -> bool:
+        return True
+
+except ImportError:
+
+    def hasCinderX() -> bool:
+        return False
+
+
+# String encoding to use for subprocesses.
+ENCODING: str = sys.stdout.encoding or sys.getdefaultencoding()
+
+# Hack to allow subprocesses to find where the cinderx module is.
+CINDERX_PATH: str = os.path.dirname(os.path.dirname(cinderx.__file__))
+
+
+def subprocess_env() -> dict[str, str]:
+    # We have CINDERX_PATH here over the rest of sys.path because our cinderx/opcode.py
+    # library is generated on a per-version basis and ends up being thrown into cinderx
+    # at build time. When we run tests with sys.path we can end up with PythonLib on the
+    # path first and we can pick up the version which doesn't have it injected.
+    return {
+        "PYTHONPATH": CINDERX_PATH + os.path.pathsep + os.path.pathsep.join(sys.path)
+    }
+
+
+def get_cinderjit_xargs() -> list[str]:
+    args = []
+    for k, v in sys._xoptions.items():
+        if not k.startswith("jit"):
+            continue
+        elif v is True:
+            args.extend(["-X", k])
+        else:
+            args.extend(["-X", f"{k}={v}"])
+    return args
+
+
+TYield = TypeVar("TYield")
+TSend = TypeVar("TSend")
+TReturn = TypeVar("TReturn")
+
+
+def get_await_stack(
+    coro: Coroutine[TYield, TSend, TReturn],
+) -> list[Coroutine[TYield, TSend, TReturn]]:
+    """Return the chain of coroutines reachable from coro via its awaiter"""
+
+    stack = []
+    awaiter = cinder._get_coro_awaiter(coro)
+    while awaiter is not None:
+        stack.append(awaiter)
+
+        # pyre-ignore[1001]
+        awaiter = cinder._get_coro_awaiter(awaiter)
+    return stack
+
+
+def verify_stack(
+    testcase: unittest.TestCase, stack: Sequence[str], expected: Sequence[str]
+) -> None:
+    n = len(expected)
+    frames = stack[-n:]
+    testcase.assertEqual(len(frames), n, "Callstack had less frames than expected")
+
+    for actual, exp in zip(frames, expected):
+        testcase.assertTrue(
+            actual.endswith(exp),
+            f"The actual frame {actual} doesn't refer to the expected function {exp}",
+        )
+
+
+def compiles_after_one_call() -> bool:
+    """
+    Check if CinderX will automatically compile functions after they are called once.
+    """
+    return cinderx.jit.get_compile_after_n_calls() == 0
+
+
+_FT = TypeVar("_FT", bound=Callable[..., object])
+
+
+# pyre-ignore[34]: Type variable isn't present in parameters
+def passAlways(reason: str) -> Callable[[_FT], _FT]:
+    """
+    Force a test to always pass.
+    Useful when `skip` is not desired
+    (e.g. intentionally skipping tests that shouldn't be deleted)
+    """
+
+    def decorator(test_item: object) -> object:
+        if isinstance(test_item, type):
+            # apply this decorator to all "test_" methods of the test case
+            for attr_name in dir(test_item):
+                if attr_name.startswith("test_"):
+                    attr = getattr(test_item, attr_name)
+                    setattr(test_item, attr_name, passAlways(attr))
+
+        else:
+
+            @functools.wraps(test_item)
+            def pass_wrapper(*args: object, **kwargs: object) -> None:
+                return
+
+            test_item = pass_wrapper
+
+        test_item.__unittest_skip_why__ = reason
+        return test_item
+
+    if isinstance(reason, types.FunctionType):
+        test_item = reason
+        reason = ""
+        return decorator(test_item)
+    # pyre-ignore[7]: bad return type
+    return decorator
+
+
+# pyre-ignore[34]: Type variable isn't present in parameters
+def passIf(condition: object, reason: str) -> Callable[[_FT], _FT]:
+    """
+    Force a test to pass if the condition is true.
+    """
+    if condition:
+        return passAlways(reason)
+    return lambda obj: obj
+
+
+# pyre-ignore[34]: Type variable isn't present in parameters
+def passUnless(condition: object, reason: str) -> Callable[[_FT], _FT]:
+    """
+    Force a test to pass unless the condition is true.
+    """
+    if not condition:
+        return passAlways(reason)
+    return lambda obj: obj
+
+
+def skip_if_jit(reason: str) -> Callable[[Callable[..., None]], Callable[..., None]]:
+    return passIf(cinderx.jit.is_enabled(), reason)
+
+
+def skip_unless_jit(
+    reason: str,
+) -> Callable[[Callable[..., None]], Callable[..., None]]:
+    return passUnless(cinderx.jit.is_enabled(), reason)
+
+
+def skip_unless_lazy_imports(
+    reason: str = "Depends on Lazy Imports being enabled",
+) -> Callable[[Callable[..., None]], Callable[..., None]]:
+    return passUnless(hasattr(importlib, "set_lazy_imports"), reason)
+
+
+TRet = TypeVar("TRet")
+
+
+def failUnlessJITCompiled(func: Callable[..., TRet]) -> Callable[..., TRet]:
+    """
+    Fail a test if the JIT is enabled but the test body wasn't JIT-compiled.
+    """
+    if not cinderx.jit.is_enabled():
+        return func
+
+    try:
+        # force_compile raises a RuntimeError if compilation fails. If it does,
+        # defer raising an exception to when the decorated function runs.
+        cinderx.jit.force_compile(func)
+    except RuntimeError as re:
+        if re.args == ("PYJIT_RESULT_NOT_ON_JITLIST",):
+            # We generally only run tests with a jitlist under
+            # Tools/scripts/jitlist_bisect.py. In that case, we want to allow
+            # the decorated function to run under the interpreter to determine
+            # if it's the function the JIT is handling incorrectly.
+            return func
+
+        # re is cleared at the end of the except block but we need the value
+        # when wrapper() is eventually called.
+        exc: RuntimeError = re
+
+        def wrapper(*args: ...) -> None:
+            raise RuntimeError(
+                f"JIT compilation of {func.__qualname__} failed with {exc}"
+            )
+
+        return wrapper
+
+    return func
+
+
+def fail_if_deopt(func: Callable[..., TRet]) -> Callable[..., TRet]:
+    """
+    Raise a RuntimeException if _any_ deopts occur during execution of the
+    wrapped function. Note deopts occuring in nested function calls will also
+    trigger this. Also, execution will run to completion - it won't stop at the
+    point a deopt occurs.
+    """
+
+    if not cinderx.jit.is_enabled():
+        return func
+
+    def wrapper(*args: ..., **kwargs: ...) -> TRet:
+        cinderx.jit.get_and_clear_runtime_stats()
+        r = func(*args, **kwargs)
+        # pyre-ignore[6]
+        if len(deopts := cinderx.jit.get_and_clear_runtime_stats()["deopt"]):
+            raise RuntimeError(f"Deopt occured {deopts}")
+        return r
+
+    wrapper.inner_function = func
+
+    return wrapper
+
+
+def is_asan_build() -> bool:
+    try:
+        ctypes.pythonapi.__asan_init
+        return True
+    except AttributeError:
+        return False
+
+
+# This is long because ASAN + JIT + subprocess + the Python compiler can be
+# pretty slow in CI.
+SUBPROCESS_TIMEOUT_SEC = 100 if is_asan_build() else 5
+
+
+@contextmanager
+def temp_sys_path() -> Generator[Path, None, None]:
+    with tempfile.TemporaryDirectory() as tmpdir:
+        _orig_sys_modules = sys.modules
+        sys.modules = _orig_sys_modules.copy()
+        _orig_sys_path = sys.path[:]
+        sys.path.insert(0, tmpdir)
+        try:
+            yield Path(tmpdir)
+        finally:
+            sys.path[:] = _orig_sys_path
+            sys.modules = _orig_sys_modules
+
+
+class _ExceptionResult:
+    def __init__(self, exc: Exception) -> None:
+        self.exc = exc
+
+
+def run_in_subprocess(func: Callable[..., TRet]) -> Callable[..., TRet]:
+    """
+    Run a function in a subprocess.  This enables modifying process state in a
+    test without affecting other test functions.
+    """
+
+    queue: multiprocessing.Queue = multiprocessing.Queue()
+
+    def wrapper(queue: multiprocessing.Queue, *args: object) -> None:
+        try:
+            result = func(*args)
+            queue.put(result, timeout=SUBPROCESS_TIMEOUT_SEC)
+        except Exception as e:
+            queue.put(_ExceptionResult(e), timeout=SUBPROCESS_TIMEOUT_SEC)
+
+    def wrapped(*args: object) -> TRet:
+        fork = multiprocessing.get_context("fork")
+        p = fork.Process(target=wrapper, args=(queue, *args))
+        p.start()
+        value = queue.get(timeout=SUBPROCESS_TIMEOUT_SEC)
+        p.join(timeout=SUBPROCESS_TIMEOUT_SEC)
+        if isinstance(value, _ExceptionResult):
+            raise value.exc
+        return value
+
+    return wrapped
+
+
+class AssertBytecodeContainsMixin(abc.ABC):
+    @abc.abstractmethod
+    def assertIn(
+        self, expected: object, actual: Sequence[object], msg: str | None = None
+    ) -> None:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def assertTrue(self, expr: object, msg: str | None = None) -> None:
+        raise NotImplementedError
+
+    def assertBytecodeContains(
+        self,
+        func: object,
+        expected_opcode: str,
+        expected_oparg: int | None = None,
+    ) -> None:
+        try:
+            # pyre-ignore[16] - for things wrapped by fail_if_deopt()
+            inner_function = func.inner_function
+        except AttributeError:
+            pass
+        else:
+            func = inner_function
+
+        bytecode_instructions = dis.get_instructions(func)
+
+        if expected_oparg is None:
+            opcodes = [instr.opname for instr in bytecode_instructions]
+            self.assertIn(
+                expected_opcode,
+                opcodes,
+                f"{expected_opcode} opcode should be present in {func.__name__} bytecode",
+            )
+        else:
+            matching_instructions = [
+                instr
+                for instr in bytecode_instructions
+                if instr.opname == expected_opcode and instr.arg == expected_oparg
+            ]
+            self.assertTrue(
+                len(matching_instructions) > 0,
+                f"{expected_opcode} opcode with oparg {expected_oparg} should be present in {func.__name__} bytecode",
+            )

cinderx-2026.1.16.2.dist-info/METADATA

@@ -0,0 +1,15 @@
+Metadata-Version: 2.4
+Name: cinderx
+Version: 2026.1.16.2
+Summary: High-performance Python runtime extension
+Home-page: https://www.github.com/facebookincubator/cinderx
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Requires-Python: >=3.14,<3.16
+License-File: LICENSE
+Dynamic: classifier
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-python
+Dynamic: summary

cinderx-2026.1.16.2.dist-info/RECORD

@@ -0,0 +1,68 @@
+_cinderx.so,sha256=HG6ruF2h6XQJPDVna4gFVBO2-1xO1G_Bfxb78RgI_Vo,86497032
+__static__/__init__.py,sha256=0joSfJlfTXAsn2v32Mu1A6WHXOORtaKt1o0x805qzZQ,15255
+__static__/compiler_flags.py,sha256=jtQ3-hAAzUPoz5Qa4gQoDz7tVjhhe1HS3RkTJo8HTPg,198
+__static__/enum.py,sha256=_XgWKshipOcJa_JRX7JHSmGrlq_U4sZy0QN5BiEG8hc,4973
+__static__/native_utils.py,sha256=BImkLhZOL4lIH0J2d3F6z2_9nm7rIn-xSNz6Kon8N0c,1914
+__static__/type_code.py,sha256=vdBKmTtsIEH6I2Mtvo_JGRzBVPKj8zuve5RYN93IacA,924
+__strict__/__init__.py,sha256=n2VcZf_XT_NszlvjITc8sdtJYi9ILklaK39EsaS02TI,790
+cinderx/__init__.py,sha256=5FNOK3vcxaN2-Isu-COoJU-OTdwc9Ujv_1dhq36W_tI,19493
+cinderx/_asyncio.py,sha256=Msix3WILwFrubkq2zcMEZTK8WJyl-zBy3Fvxxm1_E94,6371
+cinderx/compileall.py,sha256=9reYsJEOncT-Td0-8pFIN7Rcs9GeLTPftXBX3qrJ0g8,23963
+cinderx/jit.py,sha256=QDj-xrsHY_6a7sRGN7zExVWugaoUI1rtPAXeB93g9Xc,6210
+cinderx/opcode.py,sha256=NG2GwWI69WSVY-w9qA29KDEznw4hZdpE3otvMjeSYKI,6450
+cinderx/static.py,sha256=TTY6wMakkSZvlMUYcz6bBMEZ26W19CXYQV3PzpvVhIU,2493
+cinderx/strictmodule.py,sha256=Rcc1GNs3N77mh-LvHT-JJo06QdMMaBxnOL-YjtOnQzc,140
+cinderx/test_support.py,sha256=2kZdc73BLCMjs_02VYTGg36abc1N9QTKm2_t0l9oghk,10245
+cinderx/__pycache__/__init__.cpython-314.pyc,sha256=V-mJJtuh05PQvOJG2QlAMlGLI8B0GP8E33T0HBLS5Pc,29602
+cinderx/compiler/__init__.py,sha256=3nlRsYnqRzsPhjVC1FOvj59POUbyUvKFqq4ifpNGavg,1092
+cinderx/compiler/__main__.py,sha256=tEy0RbdRXw_APOD09ubatLx79u4uHnnu_zGMa9rEZcU,4111
+cinderx/compiler/config.py,sha256=gcnTNYbS7XEDUI4uR6Jd3YuTL19HcT7dNrCqpo9NWcs,173
+cinderx/compiler/consts.py,sha256=5C_3Wl5TkuHSmOQjqRNhJyrM9Kv-SeUXgoioj7lWIow,1669
+cinderx/compiler/debug.py,sha256=m91yJOzIyzWZDh-bqLCAtSXCyzZuqk5Rt_iib2ZMSw8,1975
+cinderx/compiler/dis_stable.py,sha256=1Sd_rz0LeTEyT_Z1VJ8TxWI33l7qEkVeihMYHSjP5QM,9161
+cinderx/compiler/errors.py,sha256=ylueSJp1HNejcjo1Aqv0WvQfenP7v3cxrMI0fXpUYr4,4310
+cinderx/compiler/flow_graph_optimizer.py,sha256=ESxwzFQS_KzUOFhrxcVJYQuO-QSw_JCJnirfwVROT8k,45916
+cinderx/compiler/future.py,sha256=3YPXN1bxzyIYApkFTps_nT2CQy5X9IDmM8-ON467Vxg,2704
+cinderx/compiler/misc.py,sha256=0GpxepYUvQ54LLGIGCE2E0tDfYYB3Sx9nkdRE38g79Q,763
+cinderx/compiler/opcode_cinder.py,sha256=VJ1Q5-lDML6Kr5MiCqplcowAX0eOBaJp-xK6L7Nl2-4,421
+cinderx/compiler/opcode_static.py,sha256=GCalp3_hqwb4NdstcIo5eoZ9lHvfdvgEc8-GfEn5iRM,3168
+cinderx/compiler/opcodebase.py,sha256=ub9A7uSIBy8MfRUsk306iwzv50kSowpV1l5k0FBCgpI,5331
+cinderx/compiler/opcodes.py,sha256=Z9YnH4YhhrM75I5PX99945VVPS9jMRVo8P75qIb3bK0,29976
+cinderx/compiler/optimizer.py,sha256=VnWI8amCzJsJcPHSytYF4lVylB4sFxiPZU0Q2YnHcno,17841
+cinderx/compiler/pyassem.py,sha256=MPpvqSjIct66jrR6cck8QYvfRJtNEv1n_DOC26wsgg0,135073
+cinderx/compiler/pycodegen.py,sha256=YRKXA00OTmU31ukb7f8YeduLwAZKCiPBTzMdrShzGso,264017
+cinderx/compiler/pysourceloader.py,sha256=L4Ia95fOojKFuzdaARWAqa4Fk-zjXMoqvU-NcPFnS4k,1746
+cinderx/compiler/symbols.py,sha256=FtulDpVlF7gi0P9dSZQGEu01e43LECvIWQwczQP6v9s,63316
+cinderx/compiler/unparse.py,sha256=tFAWVzBgnQoWg660m7OgQXh80kcbo-z1K5ErdjPbdsU,11700
+cinderx/compiler/visitor.py,sha256=zQqiLPBhKvYBTi4xXGH_6S4Hdqsoc6CB2aBHLXtkoTk,6329
+cinderx/compiler/static/__init__.py,sha256=ULUkEhzO_JxQZUwyh8sum-BaZnRqV2_Ws4zvn9ijRdU,49041
+cinderx/compiler/static/compiler.py,sha256=fzw5ODUlIbuSSql4guUBry0nV8qAZPVr32JgGJM-sxY,27652
+cinderx/compiler/static/declaration_visitor.py,sha256=8f1g4OmFiZlMsagntK_l0g2U13aHxf6I-KNC4rfZwgU,11147
+cinderx/compiler/static/definite_assignment_checker.py,sha256=IBrjuNgPuUqWJ-0XO9chbdGSV2CTsLNXhzr9xEsepQo,8713
+cinderx/compiler/static/effects.py,sha256=3STt2F3fDbeDSokWff9M-Cw02DVLe8SnuCVdHlMmxW8,4598
+cinderx/compiler/static/module_table.py,sha256=-Tzh-aB8-l188R-OaLELxMvBv8jUgbt7ouUGn0rN76U,26724
+cinderx/compiler/static/type_binder.py,sha256=CvLy7sSBTgM_ZjHBWbevKXTVCbs8WErBUG4qspsibfI,82060
+cinderx/compiler/static/types.py,sha256=vLzWyKZoGeXWzNVsDj1f3vrRFPJfcIQXe1yG_p9lim0,368080
+cinderx/compiler/static/util.py,sha256=0MQlvH1QVW7N08ebbNTqrWA8fgKqsvSzdedUBHXEInA,2281
+cinderx/compiler/static/visitor.py,sha256=ifyMWlSh69I1foJ5vYsvXMDoFR0rMQQYsS-f-4FRE30,3382
+cinderx/compiler/strict/__init__.py,sha256=NnZOPAPJzIJ1im0yseDWP4GDJEtTF0qBjojP_nVVb54,1695
+cinderx/compiler/strict/class_conflict_checker.py,sha256=bGujlDKAp2-g_oaA3vWXhXbci81dOvJ9lzpxgBW-ZXE,7594
+cinderx/compiler/strict/code_gen_base.py,sha256=ynmYmhW4SPby6L9Yq1EtfkexsPgocMLtiu5FkOjQ7N4,13938
+cinderx/compiler/strict/common.py,sha256=GI0kcNM7iKdefrVHRxeC5Nsn6eSvw4JMpj_6wo5EbZ8,15520
+cinderx/compiler/strict/compiler.py,sha256=krOZdMOwRZgJILVdk9TXeQqLhZyQskfTYl4nYi0PhdY,11667
+cinderx/compiler/strict/feature_extractor.py,sha256=JeSwupkhlwDUpllUjKuiv5B9AuJ_KlQq-2oGUJKQFiA,4077
+cinderx/compiler/strict/flag_extractor.py,sha256=M6HQtp9LrFmrp8UeCfcpTJnW6RORIhWFfpCIfpGU36A,2803
+cinderx/compiler/strict/loader.py,sha256=VQVa_jFAul6td4gx5ZH1P7ptBz_DZWvPpXIOe3iG1dM,30837
+cinderx/compiler/strict/preprocessor.py,sha256=vwo3MrkPwbbsqv6vAWB_GONV8bh55NcEyo5glrD1Huk,227
+cinderx/compiler/strict/runtime.py,sha256=wy8Pvqaym724eJpme9iriGcQNQPrbzNDi36g187OfK8,1796
+cinderx/compiler/strict/rewriter/__init__.py,sha256=oUCv3Av8YqP6ciJMriVrLeOq55G8k9gHroCHhISCcbQ,218
+cinderx/compiler/strict/rewriter/remove_annotations.py,sha256=oDC1xzzvaQMnwDcfQ5u2Vm65yzNjt9lcH3hcIaBIZes,3003
+cinderx/compiler/strict/rewriter/rewriter.py,sha256=bs4SQcGVb3N1_IQeA-tMOajGrEitNZha0N2_VtyOcuA,31609
+opcodes/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+opcodes/assign_opcode_numbers.py,sha256=BC7tsGBtiOLEkBMRRi6F3pNVW-ZGve3g9XaMZidi2X8,8161
+opcodes/cinderx_opcodes.py,sha256=8-nTvPU-Y8p33W8iVLrC2vYvXj3jMMxeudxxFyB6QOM,3831
+cinderx-2026.1.16.2.dist-info/METADATA,sha256=e50g5aIkdOY2QcPMk9yfU3y6bDXkEnalbNjh2ci4sbo,462
+cinderx-2026.1.16.2.dist-info/WHEEL,sha256=W3HekPD1LPmaWNNpfLvJfkRKxErKmPGqCVkQ6jDfCSs,152
+cinderx-2026.1.16.2.dist-info/top_level.txt,sha256=yMDseUEaBx2jxePsSz0RIcVQe4gqqpEiYKs2nO7Y20Q,47
+cinderx-2026.1.16.2.dist-info/RECORD,,
+cinderx-2026.1.16.2.dist-info/licenses/LICENSE,sha256=2m03A-0Ry-Qr0hLHJZV8mNojy_8ZmMBfpLPZdtGljpM,1088

cinderx-2026.1.16.2.dist-info/WHEEL

@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: false
+Tag: cp314-cp314-manylinux_2_24_x86_64
+Tag: cp314-cp314-manylinux_2_28_x86_64
+

cinderx-2026.1.16.2.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Meta Platforms, Inc. and affiliates.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

cinderx-2026.1.16.2.dist-info/top_level.txt

@@ -0,0 +1,5 @@
+__static__
+__strict__
+_cinderx
+cinderx
+opcodes